Use auto properties

Author: CyrusNajmabadi

src/Workspaces/Core/Portable/CodeActions/Operations/OpenDocumentOperation.cs

@@ -12,15 +12,13 @@ namespace Microsoft.CodeAnalysis.CodeActions;
 /// </summary>
 public sealed class OpenDocumentOperation(DocumentId documentId, bool activateIfAlreadyOpen = false) : CodeActionOperation
 {
-    private readonly DocumentId _documentId = documentId ?? throw new ArgumentNullException(nameof(documentId));
-
-    public DocumentId DocumentId => _documentId;
+    public DocumentId DocumentId { get; } = documentId ?? throw new ArgumentNullException(nameof(documentId));
 
     public override void Apply(Workspace workspace, CancellationToken cancellationToken)
     {
         if (workspace.CanOpenDocuments)
         {
-            workspace.OpenDocument(_documentId, activateIfAlreadyOpen);
+            workspace.OpenDocument(DocumentId, activateIfAlreadyOpen);
         }
     }
 }

src/Workspaces/Core/Portable/CodeFixes/CodeFixContext.cs

@@ -18,10 +18,6 @@ namespace Microsoft.CodeAnalysis.CodeFixes;
 /// </summary>
 public readonly struct CodeFixContext
 {
-    private readonly TextDocument _document;
-    private readonly TextSpan _span;
-    private readonly ImmutableArray<Diagnostic> _diagnostics;
-    private readonly CancellationToken _cancellationToken;
     private readonly Action<CodeAction, ImmutableArray<Diagnostic>> _registerCodeFix;
 
     /// <summary>
@@ -50,23 +46,23 @@ public Document Document
     /// code fixes that support non-source documents by providing a non-default value for
     /// <see cref="ExportCodeFixProviderAttribute.DocumentKinds"/>
     /// </summary>
-    public TextDocument TextDocument => _document;
+    public TextDocument TextDocument { get; }
 
     /// <summary>
     /// Text span within the <see cref="Document"/> or <see cref="TextDocument"/> to fix.
     /// </summary>
-    public TextSpan Span => _span;
+    public TextSpan Span { get; }
 
     /// <summary>
     /// Diagnostics to fix.
     /// NOTE: All the diagnostics in this collection have the same <see cref="Span"/>.
     /// </summary>
-    public ImmutableArray<Diagnostic> Diagnostics => _diagnostics;
+    public ImmutableArray<Diagnostic> Diagnostics { get; }
 
     /// <summary>
     /// CancellationToken.
     /// </summary>
-    public CancellationToken CancellationToken => _cancellationToken;
+    public CancellationToken CancellationToken { get; }
 
     /// <summary>
     /// Creates a code fix context to be passed into <see cref="CodeFixProvider.RegisterCodeFixesAsync(CodeFixContext)"/> method.
@@ -126,11 +122,11 @@ public CodeFixContext(
     {
         VerifyDiagnosticsArgument(diagnostics, span);
 
-        _document = document ?? throw new ArgumentNullException(nameof(document));
-        _span = span;
-        _diagnostics = diagnostics;
+        TextDocument = document ?? throw new ArgumentNullException(nameof(document));
+        Span = span;
+        Diagnostics = diagnostics;
         _registerCodeFix = registerCodeFix ?? throw new ArgumentNullException(nameof(registerCodeFix));
-        _cancellationToken = cancellationToken;
+        CancellationToken = cancellationToken;
     }
 
     /// <summary>
@@ -229,7 +225,7 @@ public void RegisterCodeFix(CodeAction action, ImmutableArray<Diagnostic> diagno
             throw new ArgumentNullException(nameof(action));
         }
 
-        VerifyDiagnosticsArgument(diagnostics, _span);
+        VerifyDiagnosticsArgument(diagnostics, Span);
 
         // TODO: 
         // - Check that all diagnostics are unique (no duplicates).

src/Workspaces/Core/Portable/CodeStyle/CodeStyleOption.cs

@@ -25,11 +25,10 @@ internal interface ICodeStyleOption
 /// <inheritdoc cref="CodeStyleOption2{T}"/>
 public sealed class CodeStyleOption<T> : ICodeStyleOption, IEquatable<CodeStyleOption<T>>
 {
-    private readonly CodeStyleOption2<T> _codeStyleOptionImpl;
     public static CodeStyleOption<T> Default => new(default!, NotificationOption.Silent);
 
     internal CodeStyleOption(CodeStyleOption2<T> codeStyleOptionImpl)
-        => _codeStyleOptionImpl = codeStyleOptionImpl;
+        => UnderlyingOption = codeStyleOptionImpl;
 
     public CodeStyleOption(T value, NotificationOption notification)
         : this(new CodeStyleOption2<T>(value, new NotificationOption2(notification.Severity, IsExplicitlySpecified: false)))
@@ -38,39 +37,39 @@ public CodeStyleOption(T value, NotificationOption notification)
 
     public T Value
     {
-        get => _codeStyleOptionImpl.Value;
+        get => UnderlyingOption.Value;
 
         [Obsolete("Modifying a CodeStyleOption<T> is not supported.", error: true)]
         set => throw new InvalidOperationException();
     }
 
     object? ICodeStyleOption.Value => this.Value;
-    NotificationOption2 ICodeStyleOption.Notification => _codeStyleOptionImpl.Notification;
+    NotificationOption2 ICodeStyleOption.Notification => UnderlyingOption.Notification;
     ICodeStyleOption ICodeStyleOption.WithValue(object value) => new CodeStyleOption<T>((T)value, Notification);
     ICodeStyleOption ICodeStyleOption.WithNotification(NotificationOption2 notification) => new CodeStyleOption<T>(Value, (NotificationOption)notification);
 
     public NotificationOption Notification
     {
-        get => (NotificationOption)_codeStyleOptionImpl.Notification;
+        get => (NotificationOption)UnderlyingOption.Notification;
 
         [Obsolete("Modifying a CodeStyleOption<T> is not supported.", error: true)]
         set => throw new InvalidOperationException();
     }
 
-    internal CodeStyleOption2<T> UnderlyingOption => _codeStyleOptionImpl;
+    internal CodeStyleOption2<T> UnderlyingOption { get; }
 
-    public XElement ToXElement() => _codeStyleOptionImpl.ToXElement();
+    public XElement ToXElement() => UnderlyingOption.ToXElement();
 
     public static CodeStyleOption<T> FromXElement(XElement element)
         => new(CodeStyleOption2<T>.FromXElement(element));
 
     public bool Equals(CodeStyleOption<T>? other)
-        => _codeStyleOptionImpl.Equals(other?._codeStyleOptionImpl);
+        => UnderlyingOption.Equals(other?.UnderlyingOption);
 
     public override bool Equals(object? obj)
         => obj is CodeStyleOption<T> option &&
            Equals(option);
 
     public override int GetHashCode()
-        => _codeStyleOptionImpl.GetHashCode();
+        => UnderlyingOption.GetHashCode();
 }

src/Workspaces/Core/Portable/Differencing/Edit.cs

@@ -18,8 +18,6 @@ namespace Microsoft.CodeAnalysis.Differencing;
 public readonly struct Edit<TNode> : IEquatable<Edit<TNode>>
 {
     private readonly TreeComparer<TNode> _comparer;
-    private readonly EditKind _kind;
-    private readonly TNode _oldNode;
     private readonly TNode _newNode;
 
     internal Edit(EditKind kind, TreeComparer<TNode> comparer, TNode oldNode, TNode newNode)
@@ -33,12 +31,12 @@ internal Edit(EditKind kind, TreeComparer<TNode> comparer, TNode oldNode, TNode
                      !comparer.TreesEqual(oldNode, newNode));
 
         _comparer = comparer;
-        _kind = kind;
-        _oldNode = oldNode;
+        Kind = kind;
+        OldNode = oldNode;
         _newNode = newNode;
     }
 
-    public EditKind Kind => _kind;
+    public EditKind Kind { get; }
 
     /// <summary>
     /// Insert: 
@@ -50,7 +48,7 @@ internal Edit(EditKind kind, TreeComparer<TNode> comparer, TNode oldNode, TNode
     /// Move, Update: 
     /// Node in the old tree/sequence.
     /// </summary>
-    public TNode OldNode => _oldNode;
+    public TNode OldNode { get; }
 
     /// <summary>
     /// Insert: 
@@ -69,17 +67,17 @@ public override bool Equals(object obj)
 
     public bool Equals(Edit<TNode> other)
     {
-        return _kind == other._kind
-            && (_oldNode == null) ? other._oldNode == null : _oldNode.Equals(other._oldNode)
+        return Kind == other.Kind
+            && (OldNode == null) ? other.OldNode == null : OldNode.Equals(other.OldNode)
             && (_newNode == null) ? other._newNode == null : _newNode.Equals(other._newNode);
     }
 
     public override int GetHashCode()
     {
-        var hash = (int)_kind;
-        if (_oldNode != null)
+        var hash = (int)Kind;
+        if (OldNode != null)
         {
-            hash = Hash.Combine(_oldNode.GetHashCode(), hash);
+            hash = Hash.Combine(OldNode.GetHashCode(), hash);
         }
 
         if (_newNode != null)
@@ -97,17 +95,17 @@ internal string GetDebuggerDisplay()
         switch (Kind)
         {
             case EditKind.Delete:
-                return result + " [" + _oldNode.ToString() + "]" + DisplayPosition(_oldNode);
+                return result + " [" + OldNode.ToString() + "]" + DisplayPosition(OldNode);
 
             case EditKind.Insert:
                 return result + " [" + _newNode.ToString() + "]" + DisplayPosition(_newNode);
 
             case EditKind.Update:
-                return result + " [" + _oldNode.ToString() + "]" + DisplayPosition(_oldNode) + " -> [" + _newNode.ToString() + "]" + DisplayPosition(_newNode);
+                return result + " [" + OldNode.ToString() + "]" + DisplayPosition(OldNode) + " -> [" + _newNode.ToString() + "]" + DisplayPosition(_newNode);
 
             case EditKind.Move:
             case EditKind.Reorder:
-                return result + " [" + _oldNode.ToString() + "]" + DisplayPosition(_oldNode) + " -> " + DisplayPosition(_newNode);
+                return result + " [" + OldNode.ToString() + "]" + DisplayPosition(OldNode) + " -> " + DisplayPosition(_newNode);
         }
 
         return result;

src/Workspaces/Core/Portable/Differencing/EditScript.cs

@@ -15,12 +15,11 @@ namespace Microsoft.CodeAnalysis.Differencing;
 /// </summary>
 public sealed partial class EditScript<TNode>
 {
-    private readonly Match<TNode> _match;
     private readonly ImmutableArray<Edit<TNode>> _edits;
 
     internal EditScript(Match<TNode> match)
     {
-        _match = match;
+        Match = match;
 
         var edits = new List<Edit<TNode>>();
         AddUpdatesInsertsMoves(edits);
@@ -31,13 +30,13 @@ internal EditScript(Match<TNode> match)
 
     public ImmutableArray<Edit<TNode>> Edits => _edits;
 
-    public Match<TNode> Match => _match;
+    public Match<TNode> Match { get; }
 
-    private TreeComparer<TNode> Comparer => _match.Comparer;
+    private TreeComparer<TNode> Comparer => Match.Comparer;
 
-    private TNode Root1 => _match.OldRoot;
+    private TNode Root1 => Match.OldRoot;
 
-    private TNode Root2 => _match.NewRoot;
+    private TNode Root2 => Match.NewRoot;
 
     private void AddUpdatesInsertsMoves(List<Edit<TNode>> edits)
     {
@@ -86,7 +85,7 @@ private void ProcessNode(List<Edit<TNode>> edits, TNode x)
         //
         // NOTE:
         // If we needed z then we would need to be updating M' as we encounter insertions.
-        var hasPartner = _match.TryGetPartnerInTree1(x, out var w);
+        var hasPartner = Match.TryGetPartnerInTree1(x, out var w);
         var hasParent = Comparer.TryGetParent(x, out var y);
 
         if (!hasPartner)
@@ -120,7 +119,7 @@ private void ProcessNode(List<Edit<TNode>> edits, TNode x)
             // If parents of w and x don't match, it's a move.
             // iii. if not (v, y) in M'             
             // NOTE: The paper says (y, v) but that seems wrong since M': T1 -> T2 and w,v in T1 and x,y in T2.
-            if (!_match.Contains(v, y))
+            if (!Match.Contains(v, y))
             {
                 // A. Let z be the partner of y in M'. (NOTE: z not needed)
                 // B. k := FindPos(x)
@@ -154,7 +153,7 @@ private void AddDeletes(List<Edit<TNode>> edits)
 
         foreach (var w in Comparer.GetDescendants(Root1))
         {
-            if (!_match.HasPartnerInTree2(w))
+            if (!Match.HasPartnerInTree2(w))
             {
                 edits.Add(new Edit<TNode>(EditKind.Delete, Comparer, oldNode: w, newNode: default));
             }
@@ -183,7 +182,7 @@ private void AlignChildren(List<Edit<TNode>> edits, TNode w, TNode x)
         List<TNode> s1 = null;
         foreach (var e in wChildren)
         {
-            if (_match.TryGetPartnerInTree2(e, out var pw) && Comparer.GetParent(pw).Equals(x))
+            if (Match.TryGetPartnerInTree2(e, out var pw) && Comparer.GetParent(pw).Equals(x))
             {
                 s1 ??= [];
 
@@ -194,7 +193,7 @@ private void AlignChildren(List<Edit<TNode>> edits, TNode w, TNode x)
         List<TNode> s2 = null;
         foreach (var e in xChildren)
         {
-            if (_match.TryGetPartnerInTree1(e, out var px) && Comparer.GetParent(px).Equals(w))
+            if (Match.TryGetPartnerInTree1(e, out var px) && Comparer.GetParent(px).Equals(w))
             {
                 s2 ??= [];
 
@@ -210,7 +209,7 @@ private void AlignChildren(List<Edit<TNode>> edits, TNode w, TNode x)
         // Step 3, 4
         //  Define the function Equal(a,b) to be true if and only if  (a,c) in M'
         //  Let S <- LCS(S1, S2, Equal)
-        var lcs = new Match<TNode>.LongestCommonSubsequence(_match);
+        var lcs = new Match<TNode>.LongestCommonSubsequence(Match);
         var s = lcs.GetMatchingNodes(s1, s2);
 
         // Step 5
@@ -229,7 +228,7 @@ private void AlignChildren(List<Edit<TNode>> edits, TNode w, TNode x)
             // (a,b) in M
             // => b in S2 since S2 == { b | parent(b) == x && parent(partner(b)) == w }
             // (a,b) not in S
-            if (_match.TryGetPartnerInTree2(a, out var b) &&
+            if (Match.TryGetPartnerInTree2(a, out var b) &&
                 Comparer.GetParent(b).Equals(x) &&
                 !ContainsPair(s, a, b))
             {