internal void ValidateGeneratedNames()
{
// check all the variables defined within this scope.
// we're looking for uncrunched generated fields.
foreach (JsVariableField variableField in NameTable.Values)
{
if (variableField.IsGenerated
&& variableField.CrunchedName == null)
{
// we need to rename this field.
// first we need to walk all the child scopes depth-first
// looking for references to this field. Once we find a reference,
// we then need to add all the other variables referenced in those
// scopes and all above them (from here) so we know what names we
// can't use.
var avoidTable = new HashSet<string>();
GenerateAvoidList(avoidTable, variableField.Name);
// now that we have our avoid list, create a crunch enumerator from it
JsCrunchEnumerator crunchEnum = new JsCrunchEnumerator(avoidTable);
// and use it to generate a new name
variableField.CrunchedName = crunchEnum.NextName();
}
}
// recursively traverse through our children
foreach (JsActivationObject scope in ChildScopes)
{
if (!scope.Existing)
{
scope.ValidateGeneratedNames();
}
}
}
internal virtual void AutoRenameFields()
{
// if we're not known at compile time, then we can't crunch
// the local variables in this scope, because we can't know if
// something will reference any of it at runtime.
// eval is something that will make the scope unknown because we
// don't know what eval will evaluate to until runtime
if (m_isKnownAtCompileTime)
{
// get an array of all the uncrunched local variables defined in this scope
var localFields = GetUncrunchedLocals();
if (localFields != null)
{
// create a crunch-name enumerator, taking into account any fields within our
// scope that have already been crunched.
var avoidSet = new HashSet<string>();
foreach (var field in NameTable.Values)
{
// if the field can't be crunched, or if it can but we've already crunched it,
// or if it's an outer variable (that hasn't been generated) and its OWNING scope isn't known
// (and therefore we CANNOT crunch it),
// then add it to the avoid list so we don't reuse that name
if (!field.CanCrunch || field.CrunchedName != null
|| (field.OuterField != null && !field.IsGenerated && field.OwningScope != null && !field.OwningScope.IsKnownAtCompileTime))
{
avoidSet.Add(field.ToString());
}
}
var crunchEnum = new JsCrunchEnumerator(avoidSet);
foreach (var localField in localFields)
{
// if we are an unambiguous reference to a named function expression and we are not
// referenced by anyone else, then we can just skip this variable because the
// name will be stripped from the output anyway.
// we also always want to crunch "placeholder" fields.
if (localField.CanCrunch
&& (localField.RefCount > 0 || localField.IsDeclared || localField.IsPlaceholder
|| !(m_settings.RemoveFunctionExpressionNames && m_settings.IsModificationAllowed(JsTreeModifications.RemoveFunctionExpressionNames))))
{
localField.CrunchedName = crunchEnum.NextName();
}
}
}
}
// then traverse through our children
foreach (JsActivationObject scope in ChildScopes)
{
scope.AutoRenameFields();
}
}