extraTemplates = new Rewriter(
inferences, sanitizedContentOperators, errorReporter).rewrite(fileSet);
runVisitorOnAllTemplatesIncludingNewOnes(inferences,
new PerformDeprecatedNonContextualAutoescapeVisitor(
autoescapeCancellingDirectives, errorReporter, fileSet.getNodeIdGenerator()));
return extraTemplates;
}
/**
* Runs a visitor on all templates, including newly-generated ones.
*
* After running the inference engine, new re-contextualized templates have been generated,
* but haven't been folded back into the SoyFileSetNode (which happens in the SoyFileSet monster
* class).
*
*
Note this is true even for non-contextual templates. If a non-contextual template
* eventually is called by a contextual one, the call subtree will be rewritten for the alternate
* context (even though they remain non-contextually autoescaped).
*/
private void runVisitorOnAllTemplatesIncludingNewOnes(
Inferences inferences, AbstractSoyNodeVisitor visitor) {
List allTemplatesIncludingNewOnes = inferences.getAllTemplates();
for (TemplateNode templateNode : allTemplatesIncludingNewOnes) {
visitor.exec(templateNode);
}
}
/**
* Null if no typing has been done for the named template, or otherwise the context after a call
* to the named template. Since we derive templates by start context at the call site, there
* is no start context parameter.
*
* @param templateName A qualified template name.
*/
public Context getTemplateEndContext(String templateName) {
return inferences.getTemplateEndContext(templateName);
}
/**
* Maps ranges of text-nodes to contexts so that later parse passes can add attributes or
* elements.
*/
public ImmutableList getSlicedRawTextNodes() {
return slicedRawTextNodes;
}
/**
* Reports an autoescape exception.
*/
private void reportError(
ErrorReporter errorReporter, Set errorLocations, SoyAutoescapeException e) {
// First, get to the root cause of the exception, and assemble an error message indicating
// the full call stack that led to the failure.
String message = "- " + e.getMessage();
while (e.getCause() instanceof SoyAutoescapeException) {
e = (SoyAutoescapeException) e.getCause();
message += "\n- " + e.getMessage();
}
// Now that we've gotten to the leaf, let's use its source location as the canonical one for
// reporting and de-duping. (We might otherwise end up reporting a single error multiple times
// because a single template was called by multiple other contextual templates.)
// TODO(gboyer): Delete this logic once deprecated-contextual is removed.
SourceLocation location = Preconditions.checkNotNull(e.getSourceLocation());
if (errorLocations.contains(location)) {
return;
}
errorLocations.add(location);
errorReporter.report(location, AUTOESCAPE_ERROR, message);
}
/**
* Fills in the {@link Inferences} template name to node map.
* @param files Modified in place.
*/
private static Map> findTemplates(
Iterable files) {
final Map> templatesByName
= Maps.newLinkedHashMap();
for (SoyFileNode file : files) {
for (TemplateNode template : file.getChildren()) {
String templateName;
if (template instanceof TemplateBasicNode) {
templateName = template.getTemplateName();
} else {
templateName = ((TemplateDelegateNode) template).getDelTemplateName();
}
if (!templatesByName.containsKey(templateName)) {
templatesByName.put(templateName, ImmutableList.builder());
}
templatesByName.get(templateName).add(template);
}
}
final ImmutableMap.Builder> templatesByNameBuilder
= ImmutableMap.builder();
for (Map.Entry> e : templatesByName.entrySet()) {
templatesByNameBuilder.put(e.getKey(), e.getValue().build());
}
return templatesByNameBuilder.build();
}
private static final Predicate REQUIRES_INFERENCE
= new Predicate() {
@Override
public boolean apply(TemplateNode templateNode) {
// All strict and contextual. With strict, every template establishes its own context.
// With contextual, even if we don't see any callers in the call graph, it still might be
// called from another file. This used to skip private templates, but private supposedly
// only means the template can only be called by other templates, and even then, it is
// not really enforced strongly by the Closure JS Compiler. (Prior to changing this,
// there were a few templates that weren't contextually autoescaped because they were
// private, but were still being called directly from JS.)
return templateNode.getAutoescapeMode() == AutoescapeMode.STRICT ||
templateNode.getAutoescapeMode() == AutoescapeMode.CONTEXTUAL;
}
};
private static Map makeOperatorKindMap(
final ImmutableMap soyDirectivesMap) {
ImmutableMap.Builder operatorKindMapBuilder
= ImmutableMap.builder();
for (SoyPrintDirective directive : soyDirectivesMap.values()) {
if (directive instanceof SanitizedContentOperator) {
operatorKindMapBuilder.put(
directive.getName(), ((SanitizedContentOperator) directive).getContentKind());
}
}
return operatorKindMapBuilder.build();
}
private final class NonContextualTypedRenderUnitNodesVisitor
extends AbstractSoyNodeVisitor {
final ErrorReporter errorReporter;
NonContextualTypedRenderUnitNodesVisitor(ErrorReporter errorReporter) {
this.errorReporter = errorReporter;
}
@Override protected void visitTemplateNode(TemplateNode node) {
if (node.getAutoescapeMode() == AutoescapeMode.NONCONTEXTUAL) {
visitChildren(node);
}
}
@Override protected void visitLetContentNode(LetContentNode node) {
visitRenderUnitNode(node);
}
@Override protected void visitCallParamContentNode(CallParamContentNode node) {
visitRenderUnitNode(node);
}
protected void visitRenderUnitNode(RenderUnitNode node) {
if (node.getContentKind() != null) {
// Not visiting children in this block.
// In processing a strict block (any block with a kind), contextualAutoescaper will
// automatically go into the children.
// Secondly, CheckEscapingSanityVisitor makes sure that all the children {let} or {param}
// blocks of a strict {let} or {param} block are also strict.
ImmutableList.Builder slicedRawTextNodesBuilder =
ImmutableList.builder();
InferenceEngine.inferStrictRenderUnitNode(
// As this visitor visits only non-contextual templates.
AutoescapeMode.NONCONTEXTUAL,
node,
inferences,
autoescapeCancellingDirectives,
slicedRawTextNodesBuilder,
errorReporter);
} else {
visitChildren(node);
}
}
@Override protected void visitSoyNode(SoyNode node) {
if (node instanceof ParentSoyNode) {
visitChildren((ParentSoyNode) node);
}
}
}
}