Tabular Editor erroring out on a custom code

[aman-hitachi]

We have below script in our project to do a specific process of breaking changes.

bool debug = false;

#region Error Helpers
    Action<string> ThrowError = (description) =>
    {
        throw new InvalidOperationException(description);
    };

    Action<bool, string> ThrowErrorIf = (error,description) =>
    {
        if (error)
        {
            ThrowError(description);
        }
    };
#endregion

#region General Helpers
    Func<string, string> NullIfStringEmpty = (x) => x == string.Empty ? null : x;

    Func<System.Text.RegularExpressions.Match, string, string> GetMatchGroupValue = (match, groupName) =>
    {
        return NullIfStringEmpty(match.Groups[groupName].Value.Trim());
    };

    Func<string, int?> GetNullableInt = (stringVal) =>
    {
        int tempVal;
        return int.TryParse(stringVal, out tempVal) ? tempVal : (int?)null;
    };
#endregion

#region Tabular Editor Helpers
Action<IAnnotationObject, Table> MoveObject = (obj, toTable) =>
    {
        UI.UIController.Current.Handler.Actions.MoveObject((IFolderObject)obj, toTable, false);
    };

    Action<IAnnotationObject[], Table> MoveObjects = (objects, toTable) =>
    {
        foreach (IAnnotationObject obj in objects)
        {
            MoveObject(obj, toTable);
        }
    };
    Action<IAnnotationObject, string> RenameObject = (obj, newName) =>
    {
        ((ITabularNamedObject)obj).Name = newName;
    };

    Action<IAnnotationObject> DeleteObject = (obj) =>
    {
        ((TabularNamedObject)obj).Delete();
    };

    Action<IAnnotationObject> HideObject = (obj) => ((IHideableObject)obj).IsHidden = true;

    Func<string, string, TabularObject> TryResolveObjectFromParts = (table, field) =>
    {
        // if field doesn't exist ResolveObjectPath does return null. It just exceptions if the table doesn't exist, so we first actively check for it
        if (!Model.Tables.Contains(table)) { return null; }
        if (field == null || field.Length == 0)
        {
            return Model.Tables[table];
        }
        if (field.Contains(".")) { field = "[" + field + "]"; }
        // Tabular Editor broke this, so we now need to try a couple of different options
        //return ResolveObjectPath(string.Format("Model.{0}.{1}", table, field));
        TabularObject foundObject;
        foundObject = ResolveObjectPath(string.Format("Model.T.{0}.C.{1}", table, field)); // try to find column
        if (foundObject == null) {
            foundObject = ResolveObjectPath(string.Format("Model.T.{0}.M.{1}", table, field)); // try to find measure
        }
        return foundObject; // if still null then neither column or measure can be found
    };

    Action<IAnnotationObject> RemoveBreakingChangeAnnotation = (obj) => obj.SetAnnotation("BreakingChange", null);

    Func<IAnnotationObject, Table> GetTable = (obj) =>
    {
        return ((ITabularObject)obj).ObjectType == ObjectType.Table ? (Table)obj : ((ITabularTableObject)obj).Table;
    };

    Func<IAnnotationObject, string> GetObjectName = (obj) => ((ITabularNamedObject)obj).Name;

    Func<IAnnotationObject, string> GetTableName = (obj) =>
    {
        return ((ITabularObject)obj).ObjectType == ObjectType.Table ? GetObjectName(obj) : ((ITabularNamedObject)GetTable(obj)).Name;
    };

    Func<IAnnotationObject, string, IAnnotationObject> Clone = (obj, newName) =>
    {
        return (IAnnotationObject)((IClonableObject)obj).Clone(newName);
    };

    // Loop through all the tables/measures and columnswith a Derivatives Annotation
    Func<string, System.Collections.Generic.List<ITabularNamedObject>> GetAllObjectsWithAnnotation = (annotationName) =>
    {
        var measureObjects = Model.AllMeasures
            .Where(m => m.GetAnnotation(annotationName) != null)
            .Select(r => r as ITabularNamedObject);
        var columnObjects = Model.AllColumns
            .Where(m => m.GetAnnotation(annotationName) != null)
            .Select(r => r as ITabularNamedObject);
        var tableObjects = Model.Tables
            .Where(m => m.GetAnnotation(annotationName) != null)
            .Select(r => r as ITabularNamedObject);
        var allObjects = measureObjects
            .Concat(columnObjects)
            .Concat(tableObjects)
            .ToList();
        return allObjects;
    };

    Func<string, System.Collections.Generic.List<ITabularNamedObject>> GetAllAutoDerivativesForMeasure = (derivedFromMeasure) =>
    {
        return Model.AllMeasures
            .Where(m => m.GetAnnotation("AutoDerivedFrom") == derivedFromMeasure )
            .Select(r => r as ITabularNamedObject)
            .ToList();
    };

    Func<string, string, string> GetFQFieldName = (table, field) => string.Format("'{0}'[{1}]", table, field);

    Func<string, string> GetFQTableName = (table) => string.Format("'{0}'", table);

    Func<string, string, string> GetFQName = (table, field) =>
    {
        if (field == null || field.Length == 0)
        {
            return GetFQTableName(table);
        }
        else
        {
            return GetFQFieldName(table, field);
        }
    };

    var DaxFQNameRegEx = @"(?<TableName>[^\[']+)'\s*?\[(?<FieldName>[^]]+)\]";
    Func<string, string> GetTableFromFQName = (FQName) =>
    {
        return System.Text.RegularExpressions.Regex.Match(FQName, DaxFQNameRegEx).Groups["TableName"].Value;
    };

    Func<string, string> GetFieldFromFQName = (FQName) =>
    {
        return System.Text.RegularExpressions.Regex.Match(FQName, DaxFQNameRegEx).Groups["FieldName"].Value;
    };

    Func<IAnnotationObject, string> GetFullName = (obj) =>
    {
        if (obj.ObjectType != ObjectType.Table)
        {
            return GetFQFieldName(((ITabularTableObject)obj).Table.Name, ((ITabularNamedObject)obj).Name);
        }
        else
        {
            return GetFQTableName(((ITabularNamedObject)obj).Name);
        }
    };

    Func<IAnnotationObject, string> GetObjectTypeName = (obj) => ((ITabularObject)obj).ObjectType.ToString();

    Func<IAnnotationObject, string> GetObjectTypeAndFullName = (obj) => string.Format("{0} {1}", GetObjectTypeName(obj), GetFullName(obj));
#endregion

#region Breaking Change Instruction helpers
System.Text.RegularExpressions.Regex jsonBcParser = new System.Text.RegularExpressions.Regex(Model.GetAnnotation("BreakingChange_Regex"));

Func<IAnnotationObject, System.Text.RegularExpressions.Match> GetBreakingChangeMatch = (obj) =>
{
    System.Text.RegularExpressions.Match bcMatch = jsonBcParser.Match(obj.GetAnnotation("BreakingChange"));

    if (debug) {bcMatch.Output();}

    if (!bcMatch.Success)
    {
        ThrowError(string.Format("{0} has a BreakingChange annotation that is not valid for our Regex", GetObjectTypeAndFullName(obj)));
    }
    return bcMatch;
};
#endregion

#region Version
int? currentVersion = GetNullableInt(Model.GetAnnotation("Version"));
if (currentVersion == null)
{
    ThrowError("Version Annotation should exist on the Model and be an integer value");
}

// increment the version // while devs are testing they should use undo
Model.SetAnnotation("Version", (++currentVersion).ToString());
////currentVersion.Output();
#endregion

#region Log
// define the standard log text for each breaking change type. Note the tokens available in ReplaceTokens function above
// breaking change types that expect 2 stages have an "ing" type
string RenamingLogText             = "● @Me has been RENAMED to @RenameTo. Any report(s) using this will break on @BreakOnVersion.@Notes @WorkItemNo";
string RenamedLogText              = "● @Me was RENAMED to @RenameTo. @Notes @WorkItemNo";
string DeletingLogText             = "● @Me is being DELETED. Any report(s) using this will break on @BreakOnVersion. @OptionalReplacedBy.@Notes @WorkItemNo";
string DeletedLogText              = "● @Me has been DELETED. @OptionalReplacedBy.@Notes @WorkItemNo";
string DeprecatedLogText           = "● @Me is being DEPRECATED so it should no longer be used. @OptionalReplacedBy.@Notes @WorkItemNo";
string ChangedColumnValuesLogText  = "● The values for @Me are being CHANGED. This could affect reports that expect values for filters.@Notes @WorkItemNo";
string ChangedMeasureCalcLogText   = "● The formula for @Me is being CHANGED. Users may notice some differences in values.@Notes @WorkItemNo";

Action<System.Text.StringBuilder, string> WriteLogEntry = (sb, message) => sb.Append(message + "\r\n");
#endregion

// Now initialise and start the logs
System.Text.StringBuilder softWarningLog = new System.Text.StringBuilder();
System.Text.StringBuilder finalWarningLog = new System.Text.StringBuilder();

// --------------------------------------------------------------------------------------------
// This is the main loop. We go through each object with a BreakingChange annotation, parse it and action
// it accordingly and write the appropriate log to be sent out to users
// --------------------------------------------------------------------------------------------

if (debug) { GetAllObjectsWithAnnotation("BreakingChange").Output(); }
foreach (IAnnotationObject bcObject in GetAllObjectsWithAnnotation("BreakingChange"))
{
    // ----------------------------------------------------------------------------
    // First there is a lot of setup and helpers to define to allow simpler action logic
    // for each breaking change
    // ---------------------------------------------------------------------------

    // Get the breaking change instruction into a variable
    var bcMatch = GetBreakingChangeMatch(bcObject);
    var breakingChange = new {
        Type                        = GetMatchGroupValue(bcMatch, "Type"),
        NoOfVersionsBeforeBreak     = GetNullableInt(GetMatchGroupValue(bcMatch, "NoOfVersionsBeforeBreak")),
        BreakOnVersion              = GetNullableInt(Model.GetAnnotation("BreakingChange_BreakOnVersion")),
        RenameTo                    = GetMatchGroupValue(bcMatch, "RenameTo"),
        RenameToTableName           = GetMatchGroupValue(bcMatch, "RenameToTableName") ?? (bcObject.ObjectType == ObjectType.Table ? GetMatchGroupValue(bcMatch, "RenameToSimpleFieldName") : null) ?? GetTableName(bcObject),
        RenameToFieldName           = GetMatchGroupValue(bcMatch, "RenameToTableFieldName") ?? (bcObject.ObjectType != ObjectType.Table ? GetMatchGroupValue(bcMatch, "RenameToSimpleFieldName") : null),
        OptionalReplacedBy          = GetMatchGroupValue(bcMatch, "OptionalReplacedBy"),
        OptionalReplacedByTableName = GetMatchGroupValue(bcMatch, "OptionalReplacedByTableName") ?? (bcObject.ObjectType == ObjectType.Table ? GetMatchGroupValue(bcMatch, "OptionalReplacedBySimpleFieldName") : null) ?? GetTableName(bcObject),
        OptionalReplacedByFieldName = GetMatchGroupValue(bcMatch, "OptionalReplacedByTableFieldName") ?? (bcObject.ObjectType != ObjectType.Table ? GetMatchGroupValue(bcMatch, "OptionalReplacedBySimpleFieldName") : null),
        WorkItemNo                  = GetMatchGroupValue(bcMatch, "WorkItemNo"),
        Notes                       = GetMatchGroupValue(bcMatch, "Notes")
    };

    if (debug) { breakingChange.Output(); }

    // Get some information that are useful for many breaking change types
    string FullName = GetFullName(bcObject);
    string ObjectTypeName = GetObjectTypeName(bcObject);
    string ObjectTypeAndFullName = GetObjectTypeAndFullName(bcObject);
    Table myTable = GetTable(bcObject);
    string myTableName = GetTableName(bcObject);
    string myFieldName = GetObjectName(bcObject);
    int? breakOnVersion = currentVersion + breakingChange.NoOfVersionsBeforeBreak;

    if (debug) { ("currentVersion:" + currentVersion + " NoOfVersionsBeforeBreak:" + breakingChange.NoOfVersionsBeforeBreak + ", breakOnVersion: " + breakOnVersion).Output(); }

    // get the AutoDerivative count so we can add this information to the log
    CustomAction(new ITabularNamedObject[] {(ITabularNamedObject)bcObject}, @"Auto Derivatives\Recreate AutoDerivatives");
    int autoDerivativeCount = GetAllAutoDerivativesForMeasure(GetObjectName(bcObject)).Count;
    CustomAction(new ITabularNamedObject[] {(ITabularNamedObject)bcObject}, @"Auto Derivatives\Delete AutoDerivatives");

    // setup some helpers to make each breaking change type logic more concise
    Action ValidateBreakOnVersionNotBeforeCurrentVersion = () =>
    {
        if (currentVersion < breakingChange.BreakOnVersion)
        {
            ThrowError(string.Format("BreakingChange.BreakOnVersion ({0}) should not be before current Version ({1}) on {2}. Did you forget to run Breaking Change on a previous version?"
            , breakingChange.BreakOnVersion, currentVersion, ObjectTypeAndFullName));
        }
    };

    Action ValidateRenameToHasValidValue = () =>
    {
        if (breakingChange.RenameTo == null)
        {
            ThrowError(string.Format("RenameTo is missing on BreakingChange for {1}. This is mandatory for {0} Types"
            , breakingChange.Type, ObjectTypeAndFullName));
        }

        if (bcObject.ObjectType != ObjectType.Table)
        { // field types
            if (breakingChange.RenameToTableName == null || breakingChange.RenameToFieldName == null )
            {
                ThrowError(string.Format("RenameTo {0} is not in the correct format on BreakingChange for {1}. Should be 'tableName'[FieldName]", breakingChange.RenameTo, ObjectTypeAndFullName));
            }
            // Check that table exist?
            if (Model.Tables.SingleOrDefault(t => t.Name == breakingChange.RenameToTableName) == null)
            {
                ThrowError(string.Format("RenameTo Table name '{0}' does not exist as indicated by BreakingChange for {1}. Table must exist", breakingChange.RenameToTableName, ObjectTypeAndFullName));
            }
        }
        else if (bcObject.ObjectType == ObjectType.Table)
        { // table types
            if (!(breakingChange.RenameToTableName != null || breakingChange.RenameToFieldName == null ))
            {
                ThrowError(string.Format("RenameTo {0} is not in the correct format on BreakingChange for {1}. Should be simply \"tableName\"", breakingChange.RenameTo, ObjectTypeAndFullName));
            }
        }
    };

    Action ValidateRenameToNotExists = () =>
    {
        // Object should not already exist!
        if (TryResolveObjectFromParts(breakingChange.RenameToTableName, breakingChange.RenameToFieldName) != null)
        {
            ThrowError(string.Format("RenameTo object {0} already exists for BreakingChange for {1}. RenameTo object should not already exist", breakingChange.RenameTo, ObjectTypeAndFullName));
        }
    };

    Func<TabularObject> GetOptionalReplacedByObject = () => TryResolveObjectFromParts(breakingChange.OptionalReplacedByTableName, breakingChange.OptionalReplacedByFieldName);

    Action ValidateOptionalReplacedByField = () =>
    {
        if (breakingChange.OptionalReplacedBy == null)
            return;

        var field = GetOptionalReplacedByObject();

        if (field == null)
            ThrowError(string.Format(@"OptionalReplacedBy {0} does not exist in model as indicated by BreakingChange for {1}. Should be format ""'tableName'[FieldName]"", ""TableName"" or ""FieldName"" (if in the same table)"
                , breakingChange.OptionalReplacedBy, ObjectTypeAndFullName));
    };

    Func<string> GetOptionalReplacedByFieldMessage = () =>
    {
        if (breakingChange.OptionalReplacedBy == null)
            return "It is not being replaced";
        else
        {
            IAnnotationObject obj = (IAnnotationObject)GetOptionalReplacedByObject();
            return string.Format("please use {0} instead", GetFullName(obj));
        }
    };

    Action ValidateNotesHasValue = () =>
    {
        var message = string.Format("Breaking Change Error on {0}. 'Notes' should be more descriptive for {1} breaking changes", ObjectTypeAndFullName, breakingChange.Type);
        ThrowErrorIf(breakingChange.Notes == null || breakingChange.Notes.Length < 3, message);
    };

    // Replace common tokens used for the log entries
    Func<string, string> ReplaceTokens = (input) =>
    {
        return string.Format(input
            .Replace("@Me","{0}")
            .Replace("@RenameTo","{1}")
            .Replace("@BreakOnVersion", "{2}")
            .Replace("@Notes", "{3}")
            .Replace("@WorkItemNo", "{4}")
            .Replace("@OptionalReplacedBy", "{5}"),
            new object[]
            {   ObjectTypeAndFullName + (autoDerivativeCount > 0 ? string.Format(" (and its {0} derivatives *)",autoDerivativeCount):""),
                GetFQName(breakingChange.RenameToTableName, breakingChange.RenameToFieldName),
                "v"+breakOnVersion.ToString(),
                breakingChange.Notes,
                "(#"+breakingChange.WorkItemNo+")",
                GetOptionalReplacedByFieldMessage()
            });
    };

    // helpers to write the right text to the right log
    Action WriteLogEntryRenaming             = () => WriteLogEntry(softWarningLog,  ReplaceTokens(RenamingLogText));
    Action WriteLogEntryRenamed              = () => WriteLogEntry(finalWarningLog, ReplaceTokens(RenamedLogText));
    Action WriteLogEntryDeleting             = () => WriteLogEntry(softWarningLog,  ReplaceTokens(DeletingLogText));
    Action WriteLogEntryDeleted              = () => WriteLogEntry(finalWarningLog, ReplaceTokens(DeletedLogText));
    Action WriteLogEntryDeprecated           = () => WriteLogEntry(finalWarningLog, ReplaceTokens(DeprecatedLogText));
    Action WriteLogEntryChangedColumnValues  = () => WriteLogEntry(finalWarningLog, ReplaceTokens(ChangedColumnValuesLogText));
    Action WriteLogEntryChangedMeasureCalc   = () => WriteLogEntry(finalWarningLog, ReplaceTokens(ChangedMeasureCalcLogText));

    // ----------------------------------------------
    // specific logic for each breaking change type
    // ----------------------------------------------
    if (breakingChange.Type == "Soft Rename" || breakingChange.Type == "Hard Rename")
    {
        // Validate that we have the right values for the type
        ThrowErrorIf(bcObject.ObjectType == ObjectType.Table && breakingChange.Type == "Soft Rename", string.Format("Soft Rename currently doesn't support Tables it is quite complex as you have to move Measures to the new table, duplicate all coloumns/partitions etc. Please consider alternatives and if really needed this will need to be implemented", ObjectTypeAndFullName));
        //ValidateBreakingVersionXor();
        ValidateBreakOnVersionNotBeforeCurrentVersion();
        ValidateRenameToHasValidValue();

        // Are we first or second part of the process
        if (bcObject.GetAnnotation("BreakingChange_BreakOnVersion") == null) // first stage
        {
            bool renameToSameTable = myTableName == breakingChange.RenameToTableName;
            bool renameToSameFieldName = myFieldName == breakingChange.RenameToFieldName;

            ThrowErrorIf(renameToSameTable && renameToSameFieldName, string.Format("BreakingChange Soft Rename is renaming to the same table and field name as itself. Doesn't make much sense!", ObjectTypeAndFullName));
            ValidateRenameToNotExists();

            if (bcObject.ObjectType != ObjectType.Table)
            {
                if (!renameToSameTable)
                { // move the field to the destination table first
                    // this doesn't rename references. Raise a Tabular Editor issue for this
                    // the other problem with MoveObject is that it invalidates bcObject which means we will need to refind it.
                    // We might revisit this, so leaving the code but as this is a fairly rare need, lets just error for now
                    ThrowError(string.Format("{0} is trying to rename to a different table. Field renames must be to the same table. Use Delete with OptionalReplacedBy to indicate to users what they should use instead", ObjectTypeAndFullName)) ;
                    //// MoveObject(bcObject, Model.Tables[breakingChange.RenameToTableName]);
                    //// RenameObject(bcObject, breakingChange.RenameToFieldName); // in case we are renaming the field name as well as changing the table
                }
                else // we are renaming to the same table
                {
                    RenameObject(bcObject, breakingChange.RenameToFieldName); // this will automatically update all references
                }
            }
            else // table rename
            {
                RenameObject(bcObject, breakingChange.RenameToTableName); // this will automatically update all references
            }

            if (breakingChange.Type.StartsWith("Soft")) // soft change
            {
                bcObject.SetAnnotation("BreakingChange_BreakOnVersion", breakOnVersion.ToString());

                // This is to work around the issue with references not updating when being done in one go
                bcObject.SetAnnotation("BreakingChange_RenamedFrom", GetFQFieldName(myTableName, myFieldName));
                // now we have renamed, reget the field - THIS DOESN'T WORK SO WE DO A LOOP AFTER THIS LOOP FINISHES - once we have fixed we can move that section to the below ////TabularObject renamedObject = FindRenameToField();

                WriteLogEntryRenaming();
            }
            else // hard change
            {
                WriteLogEntryRenamed();
                RemoveBreakingChangeAnnotation(bcObject);
            }
        }
        else // second stage
        {
            if (GetNullableInt(bcObject.GetAnnotation("BreakingChange_BreakOnVersion")) == currentVersion) // once we get to the trigger point
            {
                DeleteObject(bcObject);
                WriteLogEntryRenamed();
            }
        }
    }
    else if (breakingChange.Type == "Soft Delete" || breakingChange.Type == "Hard Delete")
    {
        //ThrowErrorIf(bcObject.ObjectType == ObjectType.Table, string.Format("Breaking Change Error on {0}. BreakingChange Soft Delete currently doesn't support Tables it is quite complex as you have to alert on all fields etc. Please consider alternatives and if really needed this will need to be implemented", ObjectTypeAndFullName));
        ValidateOptionalReplacedByField();
        if (bcObject.GetAnnotation("BreakingChange_BreakOnVersion") == null) // first stage
        {
            if (breakingChange.Type.StartsWith("Soft")) // soft change
            {
                HideObject(bcObject);
                bcObject.SetAnnotation("BreakingChange_BreakOnVersion", breakOnVersion.ToString());
                WriteLogEntryDeleting();
            }
            else // hard change
            {
                DeleteObject(bcObject);
                WriteLogEntryDeleted();
            }
        }
        else // second stage
        {
            if (GetNullableInt(bcObject.GetAnnotation("BreakingChange_BreakOnVersion")) == currentVersion) // once we get to the trigger point
            {
                DeleteObject(bcObject);
                WriteLogEntryDeleted();
            }
        }
    }
    else if (breakingChange.Type == "Deprecate")
    {
        ValidateOptionalReplacedByField();
        ValidateNotesHasValue();
        HideObject(bcObject);
        WriteLogEntryDeprecated();
        RemoveBreakingChangeAnnotation(bcObject);
    }
    else if (breakingChange.Type == "Change Column Values")
    {
        ThrowErrorIf(bcObject.ObjectType != ObjectType.Column, string.Format("Breaking Change Error on {0}. 'Change Column Value' Breaking change should be on Columns only", ObjectTypeAndFullName));
        ValidateNotesHasValue();
        WriteLogEntryChangedColumnValues();
        RemoveBreakingChangeAnnotation(bcObject);
    }
    else if (breakingChange.Type == "Change Measure Calculation")
    {
        ThrowErrorIf(bcObject.ObjectType != ObjectType.Measure, string.Format("Breaking Change Error on {0}. 'Change Measure Calculation' Breaking change should be on Measures only", ObjectTypeAndFullName));
        ValidateNotesHasValue();
        WriteLogEntryChangedMeasureCalc();
        RemoveBreakingChangeAnnotation(bcObject);
    }
    else
    {
        ThrowError(string.Format("BreakingChange on {0} has Type {1} which is not supported", ObjectTypeAndFullName, breakingChange.Type));
    }
}

// HACK: this independent secondary loop is only required due to a TE bug https://github.com/otykier/TabularEditor/issues/236
// Once resolved, move this back to the main rename routine to simplify
// we now have renamed the field but we still need to copy to old name (to stop reports breaking for now) and Hide it
foreach (IAnnotationObject renamedObject in GetAllObjectsWithAnnotation("BreakingChange_RenamedFrom")) // only soft renames
{
    // get some useful information into variables
    string myFieldName = GetFieldFromFQName(renamedObject.GetAnnotation("BreakingChange_RenamedFrom"));
    string myTableName = GetTableFromFQName(renamedObject.GetAnnotation("BreakingChange_RenamedFrom"));
    Table myTable = Model.Tables[myTableName];
    bool renameToSameTable = myTableName == GetTableName(renamedObject);
    bool renameToSameFieldName = myFieldName == GetObjectName(renamedObject);

    // copy the field
    IAnnotationObject clonedField = null;
    if (renameToSameTable)
    {
        clonedField = Clone(renamedObject, myFieldName);
    }
    else // a bit more work to cope with to clone back to the old table
    {
        clonedField = Clone(renamedObject, "BreakingChangeCloneField");
        MoveObject(clonedField, myTable);
        RenameObject(clonedField, myFieldName);
    }

    // cleanup - remove target BreakingChange Annotation
    renamedObject.SetAnnotation("BreakingChange", null);
    renamedObject.SetAnnotation("BreakingChange_BreakOnVersion", null);
    renamedObject.SetAnnotation("BreakingChange_RenamedFrom", null);
    ((IAnnotationObject)clonedField).SetAnnotation("BreakingChange_RenamedFrom", null);

    // hide the field
    HideObject(clonedField);
}

// Only write the log annotations if we actually did something
string softWarningAnnotationName  = string.Format("BreakingChange_Log_v{0}_Soft" ,currentVersion);
string finalWarningAnnotationName = string.Format("BreakingChange_Log_v{0}_Final",currentVersion);
if (softWarningLog.Length > 0)
{
    Model.SetAnnotation(softWarningAnnotationName, softWarningLog.ToString());
}
if (finalWarningLog.Length > 0)
{
    Model.SetAnnotation(finalWarningAnnotationName, finalWarningLog.ToString());
}

It is erroring out with a below trace

`See the end of this message for details on invoking
just-in-time (JIT) debugging instead of this dialog box.

************** Exception Text **************
System.NullReferenceException: Object reference not set to an instance of an object.
at TabularEditor.TOMWrapper.Folder.CreateFolder(Table table, String path)
at TabularEditor.TOMWrapper.TabularTree.BuildFolderForObject(IFolderObject obj)
at TabularEditor.TOMWrapper.TabularTree.RebuildFolderCacheForTable(Table table)
at TabularEditor.TOMWrapper.TabularTree.EndUpdate()
at TabularEditor.TabularUITree.EndUpdate()
at TabularEditor.TOMWrapper.TabularModelHandler.EndUpdateAll(Boolean rollback)
at TabularEditor.UI.Actions.MacroAction.Execute(Object arg)
at TabularEditor.UI.UIController.ContextMenuItem_Click(Object sender, EventArgs e)
at System.Windows.Forms.ToolStripItem.RaiseEvent(Object key, EventArgs e)
at System.Windows.Forms.ToolStripMenuItem.OnClick(EventArgs e)
at System.Windows.Forms.ToolStripItem.HandleClick(EventArgs e)
at System.Windows.Forms.ToolStripItem.HandleMouseUp(MouseEventArgs e)
at System.Windows.Forms.ToolStripItem.FireEventInteractive(EventArgs e, ToolStripItemEventType met)
at System.Windows.Forms.ToolStripItem.FireEvent(EventArgs e, ToolStripItemEventType met)
at System.Windows.Forms.ToolStrip.OnMouseUp(MouseEventArgs mea)
at System.Windows.Forms.ToolStripDropDown.OnMouseUp(MouseEventArgs mea)
at System.Windows.Forms.Control.WmMouseUp(Message& m, MouseButtons button, Int32 clicks)
at System.Windows.Forms.Control.WndProc(Message& m)
at System.Windows.Forms.ScrollableControl.WndProc(Message& m)
at System.Windows.Forms.ToolStrip.WndProc(Message& m)
at System.Windows.Forms.ToolStripDropDown.WndProc(Message& m)
at System.Windows.Forms.Control.ControlNativeWindow.OnMessage(Message& m)
at System.Windows.Forms.Control.ControlNativeWindow.WndProc(Message& m)
at System.Windows.Forms.NativeWindow.Callback(IntPtr hWnd, Int32 msg, IntPtr wparam, IntPtr lparam)

************** Loaded Assemblies **************
mscorlib
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4645.0 built by: NET48REL1LAST_B
CodeBase: file:///C:/Windows/Microsoft.NET/Framework/v4.0.30319/mscorlib.dll

TabularEditor
Assembly Version: 2.17.8266.17876
Win32 Version: 2.17.8266.17876
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/TabularEditor.exe

System
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4650.0 built by: NET48REL1LAST_C
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System/v4.0_4.0.0.0__b77a5c561934e089/System.dll

TOMWrapper
Assembly Version: 2.17.8266.17876
Win32 Version: 2.17.8266.17876
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/TabularEditor.exe

System.Windows.Forms
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4654.0 built by: NET48REL1LAST_B
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Windows.Forms/v4.0_4.0.0.0__b77a5c561934e089/System.Windows.Forms.dll

System.Drawing
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4390.0 built by: NET48REL1LAST_C
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Drawing/v4.0_4.0.0.0__b03f5f7f11d50a3a/System.Drawing.dll

System.Configuration
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4190.0 built by: NET48REL1LAST_B
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Configuration/v4.0_4.0.0.0__b03f5f7f11d50a3a/System.Configuration.dll

System.Core
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4662.0 built by: NET48REL1LAST_C
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Core/v4.0_4.0.0.0__b77a5c561934e089/System.Core.dll

System.Xml
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4084.0 built by: NET48REL1
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Xml/v4.0_4.0.0.0__b77a5c561934e089/System.Xml.dll

Microsoft.AnalysisServices.Core
Assembly Version: 19.48.0.0
Win32 Version: 16.0.43.20
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/Microsoft.AnalysisServices.Core.DLL

System.Data
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4644.0 built by: NET48REL1LAST_B
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_32/System.Data/v4.0_4.0.0.0__b77a5c561934e089/System.Data.dll

System.Net.Http
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4084.0 built by: NET48REL1
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Net.Http/v4.0_4.0.0.0__b03f5f7f11d50a3a/System.Net.Http.dll

Microsoft.AnalysisServices.Tabular
Assembly Version: 19.48.0.0
Win32 Version: 16.0.43.20
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/Microsoft.AnalysisServices.Tabular.DLL

Microsoft.AnalysisServices.Tabular.Json
Assembly Version: 19.48.0.0
Win32 Version: 16.0.43.20
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/Microsoft.AnalysisServices.Tabular.Json.DLL

System.Xml.Linq
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4084.0 built by: NET48REL1
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Xml.Linq/v4.0_4.0.0.0__b77a5c561934e089/System.Xml.Linq.dll

Microsoft.Identity.Client
Assembly Version: 4.46.1.0
Win32 Version: 4.46.1.0
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/Microsoft.Identity.Client.DLL

Microsoft.IdentityModel.Abstractions
Assembly Version: 6.18.0.0
Win32 Version: 6.18.0.30518
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/Microsoft.IdentityModel.Abstractions.DLL

System.Numerics
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4084.0 built by: NET48REL1
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Numerics/v4.0_4.0.0.0__b77a5c561934e089/System.Numerics.dll

Newtonsoft.Json
Assembly Version: 13.0.0.0
Win32 Version: 2.17.8266.17876
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/TabularEditor.exe

System.Design
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4084.0 built by: NET48REL1
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Design/v4.0_4.0.0.0__b03f5f7f11d50a3a/System.Design.dll

FastColoredTextBox
Assembly Version: 2.16.24.0
Win32 Version: 2.17.8266.17876
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/TabularEditor.exe

Crad.Windows.Forms.Actions
Assembly Version: 1.3.0.0
Win32 Version: 2.17.8266.17876
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/TabularEditor.exe

Antlr4.Runtime
Assembly Version: 4.6.0.0
Win32 Version: 2.17.8266.17876
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/TabularEditor.exe

System.Runtime.Serialization
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4536.0 built by: NET48REL1LAST_C
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Runtime.Serialization/v4.0_4.0.0.0__b77a5c561934e089/System.Runtime.Serialization.dll

hmk0egrp
Assembly Version: 0.0.0.0
Win32 Version: 4.8.4650.0 built by: NET48REL1LAST_C
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System/v4.0_4.0.0.0__b77a5c561934e089/System.dll

Microsoft.WindowsAPICodePack
Assembly Version: 1.1.2.0
Win32 Version: 2.17.8266.17876
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/TabularEditor.exe

Accessibility
Assembly Version: 4.0.0.0
Win32 Version: 4.8.4084.0 built by: NET48REL1
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/Accessibility/v4.0_4.0.0.0__b03f5f7f11d50a3a/Accessibility.dll

Microsoft.WindowsAPICodePack.Shell
Assembly Version: 1.1.0.0
Win32 Version: 2.17.8266.17876
CodeBase: file:///C:/Users/amashrivastava/source/repos/VegaDW/Depend-WebDownload/TabularEditor/TabularEditor.exe

Anonymously Hosted DynamicMethods Assembly
Assembly Version: 0.0.0.0
Win32 Version: 4.8.4645.0 built by: NET48REL1LAST_B
CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_32/mscorlib/v4.0_4.0.0.0__b77a5c561934e089/mscorlib.dll

************** JIT Debugging **************
To enable just-in-time (JIT) debugging, the .config file for this
application or computer (machine.config) must have the
jitDebugging value set in the system.windows.forms section.
The application must also be compiled with debugging
enabled.

For example:

When JIT debugging is enabled, any unhandled exception
will be sent to the JIT debugger registered on the computer
rather than be handled by this dialog box.`

[otykier]

Looks like you're using Tabular Editor 2, so I'll transfer this discussion to that repo.

[otykier]

Here is the issue in the Tabular Editor 2 repo: TabularEditor/TabularEditor#1139