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(); } }