// Decompiled with JetBrains decompiler
// Type: Microsoft.VisualStudio.Debugger.IEnumerableVisualizer.IEnumerableViewModel
// Assembly: IEnumerableVisualizer.UI, Version=18.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
// MVID: 8D605BCB-B575-4FCD-B6C8-446C06150F34
// Assembly location: C:\Program Files\Microsoft Visual Studio\18\Professional\Common7\IDE\CommonExtensions\Platform\Debugger\Visualizers\IEnumerableVisualizer.UI.dll

using Microsoft.VisualStudio.Debugger.IEnumerableVisualizer.Copilot;
using Microsoft.VisualStudio.Debugger.TabularDataUIShared;
using Microsoft.VisualStudio.Debugger.TabularDataUIShared.WPF;
using Microsoft.VisualStudio.DebuggerVisualizers;
using Microsoft.VisualStudio.Extensibility.DebuggerVisualizers;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio.Threading;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;

#nullable enable
namespace Microsoft.VisualStudio.Debugger.IEnumerableVisualizer;

internal class IEnumerableViewModel : TabularDataViewModel, IExpressionCopilotHandler
{
  private bool isMaximized;
  public volatile int LoadedDebuggeeSideRowCount;
  private bool _showTables;
  private 
  #nullable disable
  ObservableCollection<BaseTableViewModel> _tables;

  internal object VisualizerObjectSource { get; }

  internal VisualizerCommunicator Communicator { get; }

  public override string VisualizerTelemetryPrefix
  {
    get => "VS/Diagnostics/Debugger/IEnumerableVisualizer/";
  }

  public bool IsMaximized
  {
    get => this.isMaximized;
    set
    {
      if (this.isMaximized == value)
        return;
      this.isMaximized = value;
      this.OnPropertyChanged(nameof (IsMaximized));
    }
  }

  protected override async Task<bool> ExportDataToCSVAsync(string filePath, Encoding fileEncoding)
  {
    bool csvHelperAsync;
    using (StreamWriter writer = new StreamWriter(filePath, false, fileEncoding))
      csvHelperAsync = await this.ExportToCSVHelperAsync((TextWriter) writer, true);
    return csvHelperAsync;
  }

  protected override async Task<bool> CopyDataToClipboardAsync()
  {
    StringBuilder sb = new StringBuilder();
    bool clipboardAsync;
    using (StringWriter writer = new StringWriter(sb))
    {
      int num = await this.ExportToCSVHelperAsync((TextWriter) writer, false) ? 1 : 0;
      if (num != 0)
        Clipboard.SetText(sb.ToString());
      clipboardAsync = num != 0;
    }
    sb = (StringBuilder) null;
    return clipboardAsync;
  }

  protected override async Task<bool> CopySelectedDataToClipboardAsync(
    ICollection<Tuple<int, int>> cells,
    int columnStartIndex,
    int columnEndIndex,
    int rowStartIndex,
    int rowEndIndex,
    bool isRectangularAndDense)
  {
    IEnumerableViewModel ienumerableViewModel = this;
    List<ColumnInfo> list = ienumerableViewModel.SelectedTable.Columns.Where<ColumnInfo>((Func<ColumnInfo, bool>) (c => c.IsVisible && c.Index >= columnStartIndex && c.Index <= columnEndIndex)).ToList<ColumnInfo>();
    StringBuilder sb = new StringBuilder();
    using (StringWriter writer = new StringWriter(sb))
    {
      CSVWriter csvWriter = new CSVWriter(list.Select<ColumnInfo, string>((Func<ColumnInfo, string>) (c => c.DisplayName)), (TextWriter) writer);
      IEnumerable<int> columnIndiciesToExport = list.Select<ColumnInfo, int>((Func<ColumnInfo, int>) (c => c.Index));
      List<string> rowData = new List<string>(columnEndIndex - columnStartIndex);
      for (int rowIndex = rowStartIndex; rowIndex <= rowEndIndex; ++rowIndex)
      {
        if (ienumerableViewModel.CancellableAsyncOperationToken.IsCancellationRequested || ienumerableViewModel.WindowClosingCancellationToken.IsCancellationRequested)
          return false;
        RowViewModel itemAt = (RowViewModel) ienumerableViewModel.SelectedTable.CollectionView.GetItemAt(rowIndex);
        foreach (int columnIndex in columnIndiciesToExport)
        {
          if (isRectangularAndDense || cells.Contains(Tuple.Create<int, int>(rowIndex, columnIndex)))
            rowData.Add(itemAt[columnIndex]);
          else
            rowData.Add(string.Empty);
        }
        await csvWriter.WriteRowAsync((IEnumerable<string>) rowData);
        rowData.Clear();
      }
      csvWriter = (CSVWriter) null;
      columnIndiciesToExport = (IEnumerable<int>) null;
      rowData = (List<string>) null;
    }
    Clipboard.SetText(sb.ToString());
    return true;
  }

  protected override async Task<bool> RefreshUnderlyingDataAsync(CancellationToken cancelToken)
  {
    IEnumerableViewModel iEnumerableViewModel = this;
    await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(new CancellationToken());
    iEnumerableViewModel.LoadedDebuggeeSideRowCount = 0;
    iEnumerableViewModel.IsStillLoadingDebuggeeSideRows = true;
    iEnumerableViewModel.LastSearchQuery = (IVsSearchQuery) null;
    if (cancelToken.IsCancellationRequested)
      return false;
    List<TableDisplayCache> tableListAsync = await iEnumerableViewModel.Communicator.GetTableListAsync(cancelToken, true);
    int num = Math.Min(tableListAsync.Count, iEnumerableViewModel.Tables.Count);
    int count = iEnumerableViewModel.Tables.Count;
    for (int index = 0; index < num; ++index)
    {
      if (cancelToken.IsCancellationRequested)
        return false;
      TableDisplayCache tableModel = tableListAsync[index];
      if (iEnumerableViewModel.Tables[index] is TableViewModel table)
      {
        IReadOnlyList<ColumnInfo> columns = table.Columns;
        string name = table.Name;
        table.SetModel(tableModel);
        if (table.Name.Equals(name, StringComparison.Ordinal))
          iEnumerableViewModel.RestoreColumnInfo(table, columns);
        table.LoadRows();
      }
      else if (iEnumerableViewModel.Tables[index] is EmptyTableViewModel)
      {
        iEnumerableViewModel.Tables[index].ClearCache();
        iEnumerableViewModel.Tables[index] = (BaseTableViewModel) new TableViewModel(iEnumerableViewModel, tableModel);
      }
    }
    if (count > tableListAsync.Count)
    {
      for (int index = count - 1; index >= tableListAsync.Count; --index)
      {
        iEnumerableViewModel.Tables[index].ClearCache();
        iEnumerableViewModel.Tables.RemoveAt(index);
      }
    }
    else if (count < tableListAsync.Count)
    {
      for (int index = num; index < tableListAsync.Count; ++index)
      {
        TableDisplayCache tableModel = tableListAsync[index];
        iEnumerableViewModel.Tables.Add((BaseTableViewModel) new TableViewModel(iEnumerableViewModel, tableModel));
      }
    }
    await iEnumerableViewModel.InitializeVisualizerPropertiesAsync();
    return true;
  }

  private void RestoreColumnInfo(
    TableViewModel updatedTableViewModel,
    IReadOnlyList<ColumnInfo> originalColumnInfos)
  {
    foreach (ColumnInfo columnInfo in originalColumnInfos.Skip<ColumnInfo>(1))
    {
      if (columnInfo.Index >= updatedTableViewModel.Columns.Count)
        break;
      ColumnInfo column = updatedTableViewModel.Columns[columnInfo.Index];
      if (column.DisplayName.Equals(columnInfo.DisplayName, StringComparison.Ordinal))
      {
        bool flag = false;
        if (columnInfo.ChildrenIndices != null && column.IsExpandable)
        {
          this.Communicator.ExpandColumn(updatedTableViewModel.Index, columnInfo.Index);
          flag = true;
        }
        if (!columnInfo.IsVisible)
        {
          this.Communicator.HideColumn(updatedTableViewModel.Index, columnInfo.Index);
          flag = true;
        }
        if (flag)
          updatedTableViewModel.RefreshColumns();
      }
    }
  }

  private async Task<bool> ExportToCSVHelperAsync(TextWriter writer, bool shouldWriteHeaders)
  {
    IEnumerableViewModel ienumerableViewModel = this;
    List<ColumnInfo> columns = ienumerableViewModel.SelectedTable.Columns.Where<ColumnInfo>((Func<ColumnInfo, bool>) (c => c.IsVisible)).ToList<ColumnInfo>();
    if (columns.Count == 0)
    {
      await writer.WriteLineAsync();
      return true;
    }
    CSVWriter csvWriter = new CSVWriter(columns.Select<ColumnInfo, string>((Func<ColumnInfo, string>) (c => c.DisplayName)), writer);
    if (shouldWriteHeaders)
      await csvWriter.WriteHeaderAsync();
    IEnumerable<int> columnIndiciesToExport = (IEnumerable<int>) columns.Select<ColumnInfo, int>((Func<ColumnInfo, int>) (c => c.Index)).ToList<int>();
    foreach (RowViewModel rowViewModel in (IEnumerable) ienumerableViewModel.SelectedTable.CollectionView)
    {
      CancellationToken cancellationToken = ienumerableViewModel.CancellableAsyncOperationToken;
      if (!cancellationToken.IsCancellationRequested)
      {
        cancellationToken = ienumerableViewModel.WindowClosingCancellationToken;
        if (!cancellationToken.IsCancellationRequested)
        {
          List<string> rowData = new List<string>();
          foreach (int columnIndex in columnIndiciesToExport)
            rowData.Add(rowViewModel[columnIndex]);
          await csvWriter.WriteRowAsync((IEnumerable<string>) rowData);
          continue;
        }
      }
      return false;
    }
    return true;
  }

  public IEnumerableViewModel(
    VisualizerObjectSourceClient visualizerObjectSource,
    string visualizedExpression,
    JoinableTaskFactory jtf)
    : base(visualizedExpression, jtf)
  {
    this.VisualizerObjectSource = (object) (visualizerObjectSource ?? throw new ArgumentNullException(nameof (visualizerObjectSource)));
    this.Tables = new ObservableCollection<BaseTableViewModel>();
    this.Communicator = new VisualizerCommunicator(this);
  }

  public IEnumerableViewModel(
    IAsyncVisualizerObjectProvider visualizerObjectSource,
    JoinableTaskFactory jtf)
    : base((string) null, jtf)
  {
    this.VisualizerObjectSource = (object) (visualizerObjectSource ?? throw new ArgumentNullException(nameof (visualizerObjectSource)));
    this.Tables = new ObservableCollection<BaseTableViewModel>();
    this.Communicator = new VisualizerCommunicator(this);
  }

  public event EventHandler<ContextMenuCommandArgs> ColumnsUpdateAttempted;

  public event EventHandler<LatestDataAvailable> LatestDataAvailableUpdated;

  public event EventHandler<PausedOperationInfo> ContinuePausedOperation;

  public IViewHelper ViewHelper { get; set; }

  internal UpdateTableRowResult UpdateTableRowResults(
    TableViewModel table,
    int rowIndex,
    string[] values)
  {
    return this.Communicator.UpdateTableRowResults(table.Index, rowIndex, values);
  }

  internal TableDisplayCache InvalidateTableModel(TableViewModel table, out bool succeeded)
  {
    return this.Communicator.InvalidateTableCache(table.Index, out succeeded);
  }

  internal bool IsColumnLocked(ColumnInfo columnInfo)
  {
    return this.Communicator.IsColumnLocked(columnInfo);
  }

  internal void ExpandColumn(int columnIndex)
  {
    this.ContextMenuCommandHelper(Resources.G_ExpandColumnError, (Func<(bool, bool)>) (() =>
    {
      SuccessResult successResult = this.Communicator.ExpandColumn(this.SelectedTableIndex, columnIndex);
      TelemetryUtilities.LogVisualizerTelemetry((TabularDataViewModel) this, TelemetryConstants.ExpandColumnCompletedEvent, TelemetryConstants.ExpandColumnEvent, (IEnumerable<(string, string)>) new List<(string, string)>()
      {
        (TelemetryConstants.PropertyResult, FormattableString.Invariant(FormattableStringFactory.Create("{0}", (object) successResult.WasSuccessful)))
      });
      return (successResult.WasSuccessful, true);
    }));
  }

  internal void HideColumn(int columnIndex)
  {
    this.ContextMenuCommandHelper(Resources.G_HideColumnError, (Func<(bool, bool)>) (() =>
    {
      SuccessResult successResult = this.Communicator.HideColumn(this.SelectedTableIndex, columnIndex);
      if (successResult.WasSuccessful)
        this.SelectedTable.Columns[columnIndex].IsVisible = false;
      TelemetryUtilities.LogVisualizerTelemetry((TabularDataViewModel) this, TelemetryConstants.HideColumnCompletedEvent, TelemetryConstants.HideColumnEvent, (IEnumerable<(string, string)>) new List<(string, string)>()
      {
        (TelemetryConstants.PropertyResult, FormattableString.Invariant(FormattableStringFactory.Create("{0}", (object) successResult.WasSuccessful)))
      });
      return (successResult.WasSuccessful, false);
    }));
  }

  internal void HideChildren(int columnIndex)
  {
    this.ContextMenuCommandHelper(Resources.G_HideColumnsError, (Func<(bool, bool)>) (() =>
    {
      SuccessResult successResult = this.Communicator.HideChildren(this.SelectedTableIndex, columnIndex);
      if (successResult.WasSuccessful)
      {
        foreach (int childrenIndex in this.SelectedTable.Columns[columnIndex].ChildrenIndices)
          this.SelectedTable.Columns[childrenIndex].IsVisible = false;
      }
      TelemetryUtilities.LogVisualizerTelemetry((TabularDataViewModel) this, TelemetryConstants.HideChildrenCompletedEvent, TelemetryConstants.HideChildrenEvent, (IEnumerable<(string, string)>) new List<(string, string)>()
      {
        (TelemetryConstants.PropertyResult, FormattableString.Invariant(FormattableStringFactory.Create("{0}", (object) successResult.WasSuccessful)))
      });
      return (successResult.WasSuccessful, false);
    }));
  }

  private void ContextMenuCommandHelper(string errorMessage, Func<(bool, bool)> customOperation)
  {
    (bool wasSuccessful, bool flag) = customOperation();
    if (wasSuccessful & flag)
    {
      this.SelectedTable.RefreshColumns();
      this.SelectedTable.InvalidateTableModel();
    }
    EventHandler<ContextMenuCommandArgs> columnsUpdateAttempted = this.ColumnsUpdateAttempted;
    if (columnsUpdateAttempted == null)
      return;
    columnsUpdateAttempted((object) this, new ContextMenuCommandArgs(wasSuccessful, errorMessage));
  }

  public DataObjectTypeName DataObjectType { get; private set; }

  public bool ShowTables
  {
    get => this._showTables;
    set
    {
      if (this._showTables == value)
        return;
      this._showTables = value;
      this.OnPropertyChanged(nameof (ShowTables));
    }
  }

  public ObservableCollection<BaseTableViewModel> Tables
  {
    get => this._tables;
    set
    {
      if (this._tables == value)
        return;
      this._tables = value;
      this.OnPropertyChanged(nameof (Tables));
    }
  }

  public TableViewModel SelectedTable => this.Tables[this.SelectedTableIndex] as TableViewModel;

  public override ITableViewModel SelectedSimplifiedTable => (ITableViewModel) this.SelectedTable;

  public async Task StartFetchingRemainingRowsAsync(CancellationToken cancellationToken)
  {
    IEnumerableViewModel sender = this;
    bool shouldExit = false;
    sender.IsStillLoadingDebuggeeSideRows = true;
    while (!shouldExit)
    {
      CancellationToken cancellationToken1 = sender.WindowClosingCancellationToken;
      if (cancellationToken1.IsCancellationRequested || cancellationToken.IsCancellationRequested)
        break;
      int newlyLoadedRowCount = (await sender.Communicator.AdvanceIEnumerableDataSourceAsync(5000, cancellationToken)).Value;
      if (newlyLoadedRowCount != 5000)
        shouldExit = true;
      await Task.Yield();
      cancellationToken1 = sender.WindowClosingCancellationToken;
      if (!cancellationToken1.IsCancellationRequested && !cancellationToken.IsCancellationRequested)
      {
        TableViewModel selectedTable = sender.SelectedTable;
        sender.LoadedDebuggeeSideRowCount += newlyLoadedRowCount;
        if (sender.LoadedDebuggeeSideRowCount > 1000000)
        {
          sender.LoadedDebuggeeSideRowCount = 1000000;
          sender.StatusBarMessage = string.Format((IFormatProvider) CultureInfo.CurrentCulture, Resources.G_MaxRowsReached);
          shouldExit = true;
        }
        if (shouldExit)
        {
          sender.IsStillLoadingDebuggeeSideRows = false;
          IEnumerableViewModel viewModel = sender;
          string debuggeeSideRowsEvent = TelemetryConstants.FinishedLoadingDebuggeeSideRowsEvent;
          List<(string, string)> valueTupleList1 = new List<(string, string)>();
          valueTupleList1.Add((TelemetryConstants.PropertyLoadedDebuggeeSideRowCount, FormattableString.Invariant(FormattableStringFactory.Create("{0}", (object) sender.LoadedDebuggeeSideRowCount))));
          valueTupleList1.Add((TelemetryConstants.PropertyCurrentTableRowsCount, FormattableString.Invariant(FormattableStringFactory.Create("{0}", (object) selectedTable?.TableRows?.Count.GetValueOrDefault()))));
          List<(string, string)> valueTupleList2 = valueTupleList1;
          string tableColumnsCount = TelemetryConstants.PropertyCurrentTableColumnsCount;
          object[] objArray = new object[1];
          TableViewModel tableViewModel = selectedTable;
          objArray[0] = (object) (tableViewModel != null ? tableViewModel.ColumnCount : 0);
          string str = FormattableString.Invariant(FormattableStringFactory.Create("{0}", objArray));
          (string, string) valueTuple = (tableColumnsCount, str);
          valueTupleList2.Add(valueTuple);
          List<(string, string)> properties = valueTupleList1;
          await TelemetryUtilities.LogVisualizerTelemetryAsync((TabularDataViewModel) viewModel, debuggeeSideRowsEvent, (IEnumerable<(string, string)>) properties);
          if (sender.IsCancellableAsyncOperationInProgress)
          {
            EventHandler<PausedOperationInfo> continuePausedOperation = sender.ContinuePausedOperation;
            if (continuePausedOperation != null)
              continuePausedOperation((object) sender, new PausedOperationInfo(sender.AsyncOperationsTracker.LastUserAsyncOperation));
          }
        }
        if (selectedTable?.TableRows != null && selectedTable.TableRows.Count < sender.LoadedDebuggeeSideRowCount)
        {
          int num = selectedTable.TableRows.Count + (sender.LoadedDebuggeeSideRowCount - selectedTable.TableRows.Count);
          for (int count = selectedTable.TableRows.Count; count < num; ++count)
            selectedTable.TableRows.Add(new RowViewModel((ITableViewModel) selectedTable, count));
        }
        EventHandler<LatestDataAvailable> availableUpdated = sender.LatestDataAvailableUpdated;
        if (availableUpdated != null)
          availableUpdated((object) sender, new LatestDataAvailable(sender.LoadedDebuggeeSideRowCount));
        sender.RefreshSelectedRowsStatusBarText();
        selectedTable = (TableViewModel) null;
      }
    }
  }

  public override void TableRowsHaveAvailableData(
    int rowIndex,
    int rowCount,
    bool hideProgressOnCompletion)
  {
    if (this.SelectedTable?.TableRows != null)
    {
      for (int index = 0; index < rowCount; ++index)
      {
        this.SelectedTable.TableRows[rowIndex + index].HasData = true;
        this.SelectedTable.TableRows[rowIndex + index].OnValuesChanged();
      }
    }
    if (!hideProgressOnCompletion)
      return;
    this.AsyncOperationsTracker.SetAsyncOperationStatusFor(AsyncOperationsTracker.AsyncOperationType.FETCHING_PAGE, false);
  }

  public async Task InitializeAsync()
  {
    IEnumerableViewModel iEnumerableViewModel = this;
    try
    {
      foreach (TableDisplayCache tableModel in await iEnumerableViewModel.Communicator.GetTableListAsync(CancellationToken.None))
        iEnumerableViewModel.Tables.Add((BaseTableViewModel) new TableViewModel(iEnumerableViewModel, tableModel));
      await iEnumerableViewModel.InitializeVisualizerPropertiesAsync();
    }
    catch (Exception ex)
    {
      iEnumerableViewModel.IsEnabled = false;
    }
  }

  private async Task InitializeVisualizerPropertiesAsync()
  {
    IEnumerableViewModel ienumerableViewModel = this;
    ienumerableViewModel.DataObjectType = ienumerableViewModel.Communicator.DataObjectType;
    ienumerableViewModel.ShowTables = ienumerableViewModel.Tables.Count > 1;
    ienumerableViewModel.IsEnabled = ienumerableViewModel.Tables.Any<BaseTableViewModel>();
    if (!ienumerableViewModel.IsEnabled)
      ienumerableViewModel.Tables.Add((BaseTableViewModel) new EmptyTableViewModel(ienumerableViewModel));
    if (ienumerableViewModel.Tables.Count > 0)
      ienumerableViewModel.SelectedTableIndex = 0;
    await TelemetryUtilities.LogVisualizerTelemetryAsync((TabularDataViewModel) ienumerableViewModel, TelemetryConstants.InitializedEvent, (IEnumerable<(string, string)>) new List<(string, string)>()
    {
      (TelemetryConstants.PropertyTableCount, FormattableString.Invariant(FormattableStringFactory.Create("{0}", (object) ienumerableViewModel.Tables.Count)))
    });
  }

  public async Task<CopilotSessionStartResult> StartCopilotSessionAsync(
    string currentExpression,
    ExpressionReplaceCallback replaceCallback,
    CopilotSessionType sessionType,
    string additionalUserContext,
    CancellationToken cancellationToken)
  {
    TableViewModel selectedTable = this.SelectedTable;
    string type = selectedTable != null ? selectedTable.Columns.FirstOrDefault<ColumnInfo>()?.Type : (string) null;
    return NullableHelpers.IsNullOrEmpty(type) || IEnumerableCopilotService.Instance == null ? IEnumerableCopilotService.FailedSessionStart : await IEnumerableCopilotService.Instance.StartCopilotAsync(sessionType, currentExpression, type, this.GetVisualizedExpressionTypeMembers(type), replaceCallback, additionalUserContext, cancellationToken);
  }

  public async Task<bool> UpdateSessionContextAsync(
    Guid sessionId,
    string updatedExpression,
    string additionalUserContext,
    CancellationToken cancellationToken)
  {
    TableViewModel selectedTable = this.SelectedTable;
    string type = selectedTable != null ? selectedTable.Columns.FirstOrDefault<ColumnInfo>()?.Type : (string) null;
    return !NullableHelpers.IsNullOrEmpty(type) && IEnumerableCopilotService.Instance != null && await IEnumerableCopilotService.Instance.UpdateSessionContextAsync(sessionId, updatedExpression, type, this.GetVisualizedExpressionTypeMembers(type), additionalUserContext, cancellationToken);
  }

  public Task<CopilotSessionStartResult> OpenSessionInChatAsync(
    Guid sessionId,
    CancellationToken cancellationToken)
  {
    return IEnumerableCopilotService.Instance == null ? Task.FromResult<CopilotSessionStartResult>(new CopilotSessionStartResult(false, new Guid?(sessionId))) : IEnumerableCopilotService.Instance.OpenSessionInChatAsync(sessionId, cancellationToken);
  }

  public Task ShowCopilotChatToolWindowAsync(CancellationToken cancellationToken)
  {
    return IEnumerableCopilotService.ShowCopilotChatToolWindowAsync(cancellationToken);
  }

  private IEnumerable<IEnumerableTypeDefinitionEntry> GetVisualizedExpressionTypeMembers(
    string expressionTypeName)
  {
    return this.SelectedTable.Columns.Skip<ColumnInfo>(1).Select<ColumnInfo, IEnumerableTypeDefinitionEntry>((Func<ColumnInfo, IEnumerableTypeDefinitionEntry>) (c => new IEnumerableTypeDefinitionEntry(c.Type, PackageUtilities.TrimPrefix(c.DisplayName, expressionTypeName + ".", StringComparison.Ordinal))));
  }
}