of(
MethodRef.ORDAIN_AS_SAFE.invoke(constant, FieldRef.enumReference(kind).accessor()));
}
}
private String getProposedName(String prefix, String varName) {
return prefix + "_" + varName;
}
/**
* A simple object to aid in generating code for a single node.
*/
private final class CompilationUnit {
final UniqueNameGenerator fieldNames = UniqueNameGenerator.forFieldNames();
final TypeInfo type;
final TypeInfo baseClass;
final SoyNode node;
final SoyClassWriter writer;
CompilationUnit(SoyClassWriter writer, TypeInfo type, TypeInfo baseClass, SoyNode node) {
this.writer = writer;
this.type = type;
this.baseClass = baseClass;
this.node = node;
}
Expression compileExpression(ExprNode exprNode) {
final Label start = new Label();
final Label end = new Label();
final LocalVariable thisVar = createThisVar(type, start, end);
TemplateVariableManager variableSet =
new TemplateVariableManager(fieldNames, type, thisVar, DO_RESOLVE);
LazyClosureParameterLookup lookup =
new LazyClosureParameterLookup(this, parentVariableLookup, variableSet, thisVar);
SoyExpression compile =
ExpressionCompiler.createBasicCompiler(lookup, variableSet).compile(exprNode);
SoyExpression expression = compile.box();
final Statement storeExpr =
RESOLVED_VALUE
.putInstanceField(thisVar, expression)
.withSourceLocation(exprNode.getSourceLocation());
final Statement returnDone = Statement.returnExpression(RENDER_RESULT_DONE.invoke());
Statement doResolveImpl = new Statement() {
@Override void doGen(CodeBuilder adapter) {
adapter.mark(start);
storeExpr.gen(adapter);
returnDone.gen(adapter);
adapter.mark(end);
}
};
variableSet.defineStaticFields(writer);
Statement fieldInitializers = variableSet.defineFields(writer);
Expression constructExpr = generateConstructor(
new Statement() {
@Override void doGen(CodeBuilder adapter) {
adapter.loadThis();
adapter.invokeConstructor(baseClass.type(), NULLARY_INIT);
}
},
fieldInitializers,
lookup.getCapturedFields());
doResolveImpl.writeMethod(Opcodes.ACC_PROTECTED, DO_RESOLVE, writer);
return constructExpr;
}
Expression compileRenderable(RenderUnitNode renderUnit) {
FieldRef stateField = createField(type, STATE_FIELD, Type.INT_TYPE);
stateField.defineField(writer);
fieldNames.claimName(STATE_FIELD);
final Label start = new Label();
final Label end = new Label();
final LocalVariable thisVar = createThisVar(type, start, end);
final LocalVariable appendableVar =
createLocal("appendable", 1, ADVISING_APPENDABLE_TYPE, start, end).asNonNullable();
final TemplateVariableManager variableSet =
new TemplateVariableManager(fieldNames, type, thisVar, DO_RENDER);
LazyClosureParameterLookup lookup =
new LazyClosureParameterLookup(this, parentVariableLookup, variableSet, thisVar);
SoyNodeCompiler soyNodeCompiler = SoyNodeCompiler.create(registry, innerClasses, stateField,
thisVar, AppendableExpression.forLocal(appendableVar), variableSet, lookup);
CompiledMethodBody compileChildren = soyNodeCompiler.compileChildren(renderUnit);
writer.setNumDetachStates(compileChildren.numberOfDetachStates());
final Statement nodeBody = compileChildren.body();
final Statement returnDone = returnExpression(MethodRef.RENDER_RESULT_DONE.invoke());
Statement fullMethodBody = new Statement() {
@Override void doGen(CodeBuilder adapter) {
adapter.mark(start);
nodeBody.gen(adapter);
adapter.mark(end);
returnDone.gen(adapter);
thisVar.tableEntry(adapter);
appendableVar.tableEntry(adapter);
variableSet.generateTableEntries(adapter);
}
};
ContentKind kind = renderUnit.getContentKind();
final Expression contentKind = BytecodeUtils.constant(kind);
variableSet.defineStaticFields(writer);
Statement fieldInitializers = variableSet.defineFields(writer);
Statement superClassContstructor = new Statement() {
@Override void doGen(CodeBuilder adapter) {
adapter.loadThis();
contentKind.gen(adapter);
adapter.invokeConstructor(baseClass.type(), DETACHABLE_CONTENT_PROVIDER_INIT);
}
};
Expression constructExpr =
generateConstructor(superClassContstructor,
fieldInitializers,
lookup.getCapturedFields());
fullMethodBody.writeMethod(Opcodes.ACC_PROTECTED, DO_RENDER, writer);
return constructExpr;
}
/**
* Generates a public constructor that assigns our final field and checks for missing required
* params and returns an expression invoking that constructor with
*
* This constructor is called by the generate factory classes.
*/
Expression generateConstructor(final Statement superClassConstructorInvocation,
final Statement fieldInitializers,
Iterable captures) {
final Label start = new Label();
final Label end = new Label();
final LocalVariable thisVar = createThisVar(type, start, end);
final List params = new ArrayList<>();
List paramTypes = new ArrayList<>();
final List assignments = new ArrayList<>();
final List argExpressions = new ArrayList<>();
int index = 1; // start at 1 since 'this' occupied slot 0
for (ParentCapture capture : captures) {
FieldRef field = capture.field();
field.defineField(writer);
LocalVariable var = createLocal(field.name(), index, field.type(), start, end);
assignments.add(field.putInstanceField(thisVar, var));
argExpressions.add(capture.parentExpression());
params.add(var);
paramTypes.add(field.type());
index += field.type().getSize();
}
Statement constructorBody = new Statement() {
@Override void doGen(CodeBuilder cb) {
cb.mark(start);
// call super()
superClassConstructorInvocation.gen(cb);
// init fields
fieldInitializers.gen(cb);
// assign params to fields
for (Statement assignment : assignments) {
assignment.gen(cb);
}
cb.returnValue();
cb.mark(end);
thisVar.tableEntry(cb);
for (LocalVariable local : params) {
local.tableEntry(cb);
}
}
};
ConstructorRef constructor = ConstructorRef.create(type, paramTypes);
constructorBody.writeMethod(Opcodes.ACC_PUBLIC, constructor.method(), writer);
return constructor.construct(argExpressions);
}
}
/**
* Represents a field captured from our parent. To capture a value from our parent we grab the
* expression that produces that value and then generate a field in the child with the same type.
*
* {@link CompilationUnit#generateConstructor(Iterable)} generates the code to
* propagate the captured values from the parent to the child, and from the constructor to the
* generated fields.
*/
@AutoValue abstract static class ParentCapture {
static ParentCapture create(TypeInfo owner, String name, Expression parentExpression) {
FieldRef captureField = FieldRef.createFinalField(owner, name, parentExpression.resultType());
if (parentExpression.isNonNullable()) {
captureField = captureField.asNonNull();
}
return new AutoValue_LazyClosureCompiler_ParentCapture(captureField, parentExpression);
}
/** The field in the closure that stores the captured value. */
abstract FieldRef field();
/** An expression that produces the value for this capture from the parent. */
abstract Expression parentExpression();
}
/**
* The {@link LazyClosureParameterLookup} will generate expressions for all variable references
* within a lazy closure. The strategy is simple
*
*
* - If the variable is a template parameter, query the parent variable lookup and generate
* a {@link ParentCapture} for it
*
- If the variable is a local (synthetic or otherwise), check if the declaring node is a
* descendant of the current lazy node. If it is, generate code for a normal variable
* lookup (via our own VariableSet), otherwise generate a {@link ParentCapture} to grab
* the value from our parent.
*
- Finally, for the {@link RenderContext}, we lazily generate a {@link ParentCapture} if
* necessary.
*
*/
private static final class LazyClosureParameterLookup implements TemplateParameterLookup {
private final CompilationUnit params;
private final TemplateParameterLookup parentParameterLookup;
private final TemplateVariableManager variableSet;
private final Expression thisVar;
// These fields track all the parent captures that we need to generate.
private final Map paramFields = new LinkedHashMap<>();
private final Map localFields = new LinkedHashMap<>();
private final Map syntheticFields = new LinkedHashMap<>();
private ParentCapture renderContextCapture;
private ParentCapture paramsCapture;
private ParentCapture ijCapture;
LazyClosureParameterLookup(
CompilationUnit params,
TemplateParameterLookup parentParameterLookup,
TemplateVariableManager variableSet,
Expression thisVar) {
this.params = params;
this.parentParameterLookup = parentParameterLookup;
this.variableSet = variableSet;
this.thisVar = thisVar;
}
@Override public Expression getParam(TemplateParam param) {
// All params are packed into fields
ParentCapture capturedField = paramFields.get(param);
if (capturedField == null) {
String name = param.name();
params.fieldNames.claimName(name);
capturedField =
ParentCapture.create(params.type, name, parentParameterLookup.getParam(param));
paramFields.put(param, capturedField);
}
return capturedField.field().accessor(thisVar);
}
@Override public Expression getLocal(LocalVar local) {
if (isDescendantOf(local.declaringNode(), params.node)) {
// in this case, we just delegate to VariableSet
return variableSet.getVariable(local.name()).local();
}
ParentCapture capturedField = localFields.get(local);
if (capturedField == null) {
String name = params.fieldNames.generateName(local.name());
capturedField =
ParentCapture.create(params.type, name, parentParameterLookup.getLocal(local));
localFields.put(local, capturedField);
}
return capturedField.field().accessor(thisVar);
}
@Override public Expression getLocal(SyntheticVarName varName) {
if (isDescendantOf(varName.declaringNode(), params.node)) {
// in this case, we just delegate to VariableSet
return variableSet.getVariable(varName).local();
}
ParentCapture capturedField = syntheticFields.get(varName);
if (capturedField == null) {
String name = params.fieldNames.generateName(varName.name());
capturedField =
ParentCapture.create(params.type, name, parentParameterLookup.getLocal(varName));
syntheticFields.put(varName, capturedField);
}
return capturedField.field().accessor(thisVar);
}
Iterable getCapturedFields() {
return Iterables.concat(
Iterables.filter(asList(paramsCapture, ijCapture, renderContextCapture), notNull()),
paramFields.values(),
localFields.values(),
syntheticFields.values());
}
@Override public Expression getRenderContext() {
if (renderContextCapture == null) {
params.fieldNames.claimName(RENDER_CONTEXT_FIELD);
renderContextCapture =
ParentCapture.create(
params.type, RENDER_CONTEXT_FIELD, parentParameterLookup.getRenderContext());
}
return renderContextCapture.field().accessor(thisVar);
}
@Override public Expression getParamsRecord() {
if (paramsCapture == null) {
params.fieldNames.claimName(PARAMS_FIELD);
paramsCapture =
ParentCapture.create(
params.type, PARAMS_FIELD, parentParameterLookup.getParamsRecord());
}
return paramsCapture.field().accessor(thisVar);
}
@Override public Expression getIjRecord() {
if (ijCapture == null) {
params.fieldNames.claimName(IJ_FIELD);
ijCapture =
ParentCapture.create(params.type, IJ_FIELD, parentParameterLookup.getIjRecord());
}
return ijCapture.field().accessor(thisVar);
}
}
}