Merge remote-tracking branch 'upstream/master' into Issue592

src/Compilers/CSharp/Portable/Syntax/SyntaxFormatter.cs

@@ -11,6 +11,8 @@ namespace Microsoft.CodeAnalysis.CSharp.Syntax
 {
     internal class SyntaxFormatter : CSharpSyntaxRewriter
     {
+        private readonly TextSpan _consideredSpan;
+        private readonly int _initialDepth;
         private readonly string _indentWhitespace;
         private readonly bool _useElasticTrivia;
 
@@ -26,19 +28,20 @@ internal class SyntaxFormatter : CSharpSyntaxRewriter
         // of the values between indentations[0] and indentations[initialDepth] (exclusive).
         private ArrayBuilder<SyntaxTrivia> _indentations;
 
-        private SyntaxFormatter(string indentWhitespace, bool useElasticTrivia)
+        private SyntaxFormatter(TextSpan consideredSpan, int initialDepth, string indentWhitespace, bool useElasticTrivia)
             : base(visitIntoStructuredTrivia: true)
         {
+            _consideredSpan = consideredSpan;
+            _initialDepth = initialDepth;
             _indentWhitespace = indentWhitespace;
             _useElasticTrivia = useElasticTrivia;
-
             _afterLineBreak = true;
         }
 
         internal static TNode Format<TNode>(TNode node, string indentWhitespace, bool useElasticTrivia = false)
             where TNode : SyntaxNode
         {
-            var formatter = new SyntaxFormatter(indentWhitespace, useElasticTrivia);
+            var formatter = new SyntaxFormatter(node.FullSpan, GetDeclarationDepth(node), indentWhitespace, useElasticTrivia);
             var result = (TNode)formatter.Visit(node);
             formatter.Free();
             return result;
@@ -46,7 +49,7 @@ internal static TNode Format<TNode>(TNode node, string indentWhitespace, bool us
 
         internal static SyntaxToken Format(SyntaxToken token, string indentWhitespace, bool useElasticTrivia = false)
         {
-            var formatter = new SyntaxFormatter(indentWhitespace, useElasticTrivia);
+            var formatter = new SyntaxFormatter(token.FullSpan, GetDeclarationDepth(token), indentWhitespace, useElasticTrivia);
             var result = formatter.VisitToken(token);
             formatter.Free();
             return result;
@@ -54,7 +57,7 @@ internal static SyntaxToken Format(SyntaxToken token, string indentWhitespace, b
 
         internal static SyntaxTriviaList Format(SyntaxTriviaList trivia, string indentWhitespace, bool useElasticTrivia = false)
         {
-            var formatter = new SyntaxFormatter(indentWhitespace, useElasticTrivia);
+            var formatter = new SyntaxFormatter(trivia.FullSpan, GetDeclarationDepth(trivia.Token), indentWhitespace, useElasticTrivia);
             var result = formatter.RewriteTrivia(
                 trivia,
                 GetDeclarationDepth((SyntaxToken)trivia.ElementAt(0).Token),
@@ -98,8 +101,7 @@ public override SyntaxToken VisitToken(SyntaxToken token)
                     mustHaveSeparator: false,
                     lineBreaksAfter: lineBreaksAfter));
 
-                // get next token, skipping zero width tokens except for end-of-directive tokens
-                var nextToken = token.GetNextToken(t => SyntaxToken.NonZeroWidth(t) || t.Kind() == SyntaxKind.EndOfDirectiveToken, t => t.Kind() == SyntaxKind.SkippedTokensTrivia);
+                var nextToken = this.GetNextRelevantToken(token);
 
                 _afterLineBreak = EndsInLineBreak(token);
                 _afterIndentation = false;
@@ -127,8 +129,27 @@ public override SyntaxToken VisitToken(SyntaxToken token)
             }
         }
 
+        private SyntaxToken GetNextRelevantToken(SyntaxToken token)
+        {
+            // get next token, skipping zero width tokens except for end-of-directive tokens
+            var nextToken = token.GetNextToken(
+                t => SyntaxToken.NonZeroWidth(t) || t.Kind() == SyntaxKind.EndOfDirectiveToken, 
+                t => t.Kind() == SyntaxKind.SkippedTokensTrivia);
+
+            if (_consideredSpan.Contains(nextToken.FullSpan))
+            {
+                return nextToken;
+            }
+            else
+            {
+                return default(SyntaxToken);
+            }
+        }
+
         private SyntaxTrivia GetIndentation(int count)
         {
+            count = Math.Max(count - _initialDepth, 0);
+
             int capacity = count + 1;
             if (_indentations == null)
             {

src/Compilers/VisualBasic/Portable/Syntax/SyntaxFormatter.vb

@@ -10,6 +10,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Syntax
     Friend Class SyntaxFormatter
         Inherits VisualBasicSyntaxRewriter
 
+        Private ReadOnly consideredSpan As TextSpan
         Private ReadOnly indentWhitespace As String
         Private ReadOnly useElasticTrivia As Boolean
         Private ReadOnly useDefaultCasing As Boolean
@@ -35,9 +36,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Syntax
         ''' <param name="useElasticTrivia">Whether to use elastic trivia or not</param>
         ''' <param name="useDefaultCasing">Whether to rewrite keywords in default casing or not</param>
         ''' <remarks></remarks>
-        Private Sub New(indentWhitespace As String, Optional useElasticTrivia As Boolean = False, Optional useDefaultCasing As Boolean = False)
-            : MyBase.New(VisitIntoStructuredTrivia:=True)
+        Private Sub New(consideredSpan As TextSpan, indentWhitespace As String, Optional useElasticTrivia As Boolean = False, Optional useDefaultCasing As Boolean = False)
+            MyBase.New(visitIntoStructuredTrivia:=True)
 
+            Me.consideredSpan = consideredSpan
             Me.indentWhitespace = indentWhitespace
             Me.useElasticTrivia = useElasticTrivia
             Me.useDefaultCasing = useDefaultCasing
@@ -46,21 +48,21 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Syntax
         End Sub
 
         Friend Shared Function Format(Of TNode As SyntaxNode)(node As TNode, indentWhitespace As String, Optional useElasticTrivia As Boolean = False, Optional useDefaultCasing As Boolean = False) As SyntaxNode
-            Dim formatter As New SyntaxFormatter(indentWhitespace, useElasticTrivia, useDefaultCasing)
+            Dim formatter As New SyntaxFormatter(node.FullSpan, indentWhitespace, useElasticTrivia, useDefaultCasing)
             Dim result As TNode = CType(formatter.Visit(node), TNode)
             formatter.Free()
             Return result
         End Function
 
         Friend Shared Function Format(token As SyntaxToken, indentWhitespace As String, Optional useElasticTrivia As Boolean = False, Optional useDefaultCasing As Boolean = False) As SyntaxToken
-            Dim formatter As New SyntaxFormatter(indentWhitespace, useElasticTrivia, useDefaultCasing)
+            Dim formatter As New SyntaxFormatter(token.FullSpan, indentWhitespace, useElasticTrivia, useDefaultCasing)
             Dim result As SyntaxToken = formatter.VisitToken(token)
             formatter.Free()
             Return result
         End Function
 
         Friend Shared Function Format(trivia As SyntaxTriviaList, indentWhitespace As String, Optional useElasticTrivia As Boolean = False, Optional useDefaultCasing As Boolean = False) As SyntaxTriviaList
-            Dim formatter = New SyntaxFormatter(indentWhitespace, useElasticTrivia, useDefaultCasing)
+            Dim formatter = New SyntaxFormatter(trivia.FullSpan, indentWhitespace, useElasticTrivia, useDefaultCasing)
             Dim result As SyntaxTriviaList = formatter.RewriteTrivia(trivia,
                                             formatter.GetIndentationDepth(),
                                             isTrailing:=False,
@@ -659,9 +661,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Syntax
         End Function
 
         Private Function GetNextRelevantToken(token As SyntaxToken) As SyntaxToken
-            Return token.GetNextToken(Function(t As SyntaxToken)
-                                          Return t.Kind <> SyntaxKind.None
-                                      End Function, Function(t As SyntaxTrivia) False)
+            Dim nextToken = token.GetNextToken(Function(t As SyntaxToken)
+                                                   Return t.Kind <> SyntaxKind.None
+                                               End Function, Function(t As SyntaxTrivia) False)
+
+            If consideredSpan.Contains(nextToken.FullSpan) Then
+                Return nextToken
+            Else
+                Return Nothing
+            End If
+
         End Function
 
         Private Sub AddLinebreaksAfterElementsIfNeeded(Of TNode As SyntaxNode)(

src/Diagnostics/FxCop/System.Runtime.Analyzers/Test/Design/DefineAccessorsForAttributeArgumentsTests.Fixer.cs

@@ -86,8 +86,8 @@ public SetterOnlyTestAttribute(string name)
     }
 
     public string Name 
-    { 
-        set { m_name = value }
+    {
+        internal set { m_name = value }
 
         get;
     }

src/EditorFeatures/CSharpTest/Diagnostics/ImplementInterface/ImplementInterfaceTests.cs

@@ -1676,7 +1676,7 @@ public void TestImplementIDisposable_DisposePattern()
 class C : [|IDisposable|]",
 $@"using System;
 class C : IDisposable
-{{{DisposePatternWithIndentation("protected virtual ", "C", "public void ")}
+{{{string.Format(CSharpFeaturesResources.DisposePattern, "protected virtual ", "C", "public void ")}
 }}
 ", index: 1, compareTokens: false);
         }
@@ -1719,7 +1719,7 @@ class C : System.IDisposable
     class IDisposable
     {{
     }}
-{DisposePatternWithIndentation("protected virtual ", "C", "void System.IDisposable.")}
+{string.Format(CSharpFeaturesResources.DisposePattern, "protected virtual ", "C", "void System.IDisposable.")}
 }}", index: 3, compareTokens: false);
         }
 
@@ -1769,7 +1769,7 @@ public void TestImplementIDisposableExplicitly_NoNamespaceImportForSystem()
             Test(
 @"class C : [|System.IDisposable|]",
 $@"class C : System.IDisposable
-{{{DisposePatternWithIndentation("protected virtual ", "C", "void System.IDisposable.")}
+{{{string.Format(CSharpFeaturesResources.DisposePattern, "protected virtual ", "C", "void System.IDisposable.")}
 }}
 ", index: 3, compareTokens: false);
         }
@@ -1830,7 +1830,7 @@ public void F()
     {{
         throw new NotImplementedException();
     }}
-{DisposePatternWithIndentation("protected virtual ", "C", "public void ")}
+{string.Format(CSharpFeaturesResources.DisposePattern, "protected virtual ", "C", "public void ")}
 }}", index: 1, compareTokens: false);
         }
 
@@ -1858,7 +1858,7 @@ void I.F()
     {{
         throw new NotImplementedException();
     }}
-{DisposePatternWithIndentation("protected virtual ", "C", "void IDisposable.")}
+{string.Format(CSharpFeaturesResources.DisposePattern, "protected virtual ", "C", "void IDisposable.")}
 }}", index: 3, compareTokens: false);
         }
 
@@ -2295,7 +2295,7 @@ class Program : [|IDisposable|]
 
 class Program : IDisposable
 {{
-{DisposePatternWithIndentation("protected virtual ", "C", "public void ")}
+{string.Format(CSharpFeaturesResources.DisposePattern, "protected virtual ", "C", "public void ")}
 }}
 ", index: 1);
         }
@@ -2318,7 +2318,7 @@ class Program : [|IDisposable|]
 class Program : IDisposable
 {{
     private bool DisposedValue;
-{DisposePatternWithIndentation("protected virtual ", "Program", "void IDisposable.")}
+{string.Format(CSharpFeaturesResources.DisposePattern, "protected virtual ", "Program", "void IDisposable.")}
 }}
 ", index: 3);
         }
@@ -2397,7 +2397,7 @@ sealed class Program : [|IDisposable|]
 
 sealed class Program : IDisposable
 {{
-{DisposePatternWithIndentation("", "Program", "void IDisposable.")}
+{string.Format(CSharpFeaturesResources.DisposePattern, "", "Program", "void IDisposable.")}
 }}
 ", index: 3);
         }
@@ -2522,7 +2522,7 @@ public List<AggregateException> M(Dictionary<Exception, List<AggregateException>
     {{
         throw new NotImplementedException();
     }}
-{DisposePatternWithIndentation("protected virtual ", "C", "public void ")}
+{string.Format(CSharpFeaturesResources.DisposePattern, "protected virtual ", "C", "public void ")}
 }}", index: 1, compareTokens: false);
         }
 
@@ -2569,21 +2569,12 @@ bool IEquatable<int>.Equals(int other)
     {{
         throw new NotImplementedException();
     }}
-{DisposePatternWithIndentation("protected virtual ", "C", "void IDisposable.")}
+{string.Format(CSharpFeaturesResources.DisposePattern, "protected virtual ", "C", "void IDisposable.")}
 }}
 
 partial class C
 {{
 }}", index: 3, compareTokens: false);
         }
-
-        private static string DisposePatternWithIndentation(string disposeMethodModifiers, string className, string interfaceMethodModifiers, string additionalIndentation = "    ")
-        {
-            var lines = string.Format(CSharpFeaturesResources.DisposePattern, disposeMethodModifiers, className, interfaceMethodModifiers)
-                .Split('\n')
-                .Select(line => line.TrimEnd())
-                .Select(line => line.Length > 0 ? additionalIndentation + line : line); // only indent lines with content
-            return string.Join("\r\n", lines);
-        }
     }
 }

src/ExpressionEvaluator/Core/Source/Concord/Microsoft.VisualStudio.Debugger.Engine.il

@@ -39,13 +39,13 @@
   .ver 1:0:0:0
 }
 .module Microsoft.VisualStudio.Debugger.Engine.dll
-// MVID: {0F7065FE-E352-4628-8FE7-0426F0FBBB7F}
+// MVID: {F69E895E-D452-4E38-95BE-7B90DD70E62B}
 .imagebase 0x00400000
 .file alignment 0x00000200
 .stackreserve 0x00100000
 .subsystem 0x0003       // WINDOWS_CUI
 .corflags 0x00000001    //  ILONLY
-// Image base: 0x010C0000
+// Image base: 0x018D0000
 
 
 // =============== CLASS MEMBERS DECLARATION ===================

src/ExpressionEvaluator/Core/Source/Concord/Microsoft.VisualStudio.Debugger.Metadata.il

@@ -38,13 +38,13 @@
   .ver 14:0:0:0
 }
 .module Microsoft.VisualStudio.Debugger.Metadata.dll
-// MVID: {0FE2E086-DC20-4906-8692-8D635914361B}
+// MVID: {9E55C756-FD12-43E3-ADCD-A828058B43EB}
 .imagebase 0x00400000
 .file alignment 0x00000200
 .stackreserve 0x00100000
 .subsystem 0x0003       // WINDOWS_CUI
 .corflags 0x00000001    //  ILONLY
-// Image base: 0x007F0000
+// Image base: 0x00E60000
 
 
 // =============== CLASS MEMBERS DECLARATION ===================

src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Binders/PlaceholderLocalBinder.vb

@@ -76,14 +76,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
             Dim typeChar As String = Nothing
             Dim specialType = GetSpecialTypeForTypeCharacter(identifier.GetTypeCharacter(), typeChar)
             Dim type = Compilation.GetSpecialType(If(specialType = SpecialType.None, SpecialType.System_Object, specialType))
-            ' NOTE: Don't create the local with the canonical name since we want it to have the user's text in diagnostic messages.
+            ' TODO (acasey): don't canonicalize name (GH #878)
+            Dim canonicalName = Canonicalize(identifier.GetIdentifierText())
             Dim local = LocalSymbol.Create(
                 _containingMethod,
                 Me,
                 identifier,
                 LocalDeclarationKind.ImplicitVariable,
-                type)
-            _implicitDeclarations.Add(Canonicalize(local.Name), local)
+                type,
+                canonicalName)
+            _implicitDeclarations.Add(canonicalName, local)
             If local.Name.StartsWith("$", StringComparison.Ordinal) Then
                 diagnostics.Add(ERRID.ERR_IllegalChar, identifier.GetLocation())
             End If
@@ -132,7 +134,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
             End Select
         End Function
 
-        Friend Shared Function Canonicalize(name As String) As String
+        Private Shared Function Canonicalize(name As String) As String
             Return CaseInsensitiveComparison.ToLower(name)
         End Function
 

src/ExpressionEvaluator/VisualBasic/Source/ExpressionCompiler/Rewriters/LocalDeclarationRewriter.vb

@@ -60,7 +60,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ExpressionEvaluator
             ' CreateVariable(type As Type, name As String)
             Dim method = PlaceholderLocalSymbol.GetIntrinsicMethod(compilation, ExpressionCompilerConstants.CreateVariableMethodName)
             Dim type = New BoundGetType(syntax, New BoundTypeExpression(syntax, local.Type), typeType)
-            Dim name = New BoundLiteral(syntax, ConstantValue.Create(PlaceholderLocalBinder.Canonicalize(local.Name)), stringType)
+            Dim name = New BoundLiteral(syntax, ConstantValue.Create(local.Name), stringType)
             Dim expr = New BoundCall(
                 syntax,
                 method,

src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/DeclarationTests.vb

@@ -819,7 +819,7 @@ End Class"
   // Code size       16 (0x10)
   .maxstack  1
   IL_0000:  ldstr      ""x""
-  IL_0005:  call       ""Function <>x.<>GetObjectByAlias(String) As Object""
+  IL_0005:  call       ""Function Microsoft.VisualStudio.Debugger.Clr.IntrinsicMethods.GetObjectByAlias(String) As Object""
   IL_000a:  castclass  ""String""
   IL_000f:  ret
 }
@@ -861,11 +861,11 @@ End Class"
   IL_0000:  ldtoken    ""Object""
   IL_0005:  call       ""Function System.Type.GetTypeFromHandle(System.RuntimeTypeHandle) As System.Type""
   IL_000a:  ldstr      ""x""
-  IL_000f:  call       ""Sub <>x.<>CreateVariable(System.Type, String)""
+  IL_000f:  call       ""Sub Microsoft.VisualStudio.Debugger.Clr.IntrinsicMethods.CreateVariable(System.Type, String)""
   IL_0014:  ldstr      ""x""
-  IL_0019:  call       ""Function <>x.<>GetVariableAddress(Of Object)(String) As Object""
+  IL_0019:  call       ""Function Microsoft.VisualStudio.Debugger.Clr.IntrinsicMethods.GetVariableAddress(Of Object)(String) As Object""
   IL_001e:  ldstr      ""x""
-  IL_0023:  call       ""Function <>x.<>GetObjectByAlias(String) As Object""
+  IL_0023:  call       ""Function Microsoft.VisualStudio.Debugger.Clr.IntrinsicMethods.GetObjectByAlias(String) As Object""
   IL_0028:  call       ""Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object""
   IL_002d:  stind.ref
   IL_002e:  ret

src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/PseudoVariableTests.vb

@@ -462,7 +462,8 @@ End Class"
                 expr:="$ReturnValue(Of Object)",
                 resultProperties:=resultProperties,
                 errorMessage:=errorMessage)
-            Assert.Equal("(1) : error BC32045: '$ReturnValue' has no type parameters and so cannot have type arguments.", errorMessage)
+            ' TODO (acasey): don't canonicalize name (GH #878)
+            Assert.Equal("(1) : error BC32045: '$returnvalue' has no type parameters and so cannot have type arguments.", errorMessage)
 
             Const source = "
 Class C

src/Features/CSharp/CSharpFeaturesResources.Designer.cs

@@ -188,26 +188,23 @@ internal class CSharpFeaturesResources {
         
         /// <summary>
         ///   Looks up a localized string similar to 
-        ///#region IDisposable Support
-        ///private bool disposedValue = false; // To detect redundant calls
+        ///    #region IDisposable Support
+        ///    private bool disposedValue = false; // To detect redundant calls
         ///
-        ///{0}void Dispose(bool disposing)
-        ///{{
-        ///    if (!disposedValue)
+        ///    {0}void Dispose(bool disposing)
         ///    {{
-        ///        if (disposing)
+        ///        if (!disposedValue)
         ///        {{
-        ///            // TODO: dispose managed state (managed objects).
-        ///        }}
-        /// 
-        ///        // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
-        ///        // TODO: set large fields to null.
-        /// 
-        ///        disposedValue = true;
-        ///    }}
-        ///}}
+        ///            if (disposing)
+        ///            {{
+        ///                // TODO: dispose managed state (managed objects).
+        ///            }}
         ///
-        ///// TODO: override a finalizer only if Disp [rest of string was truncated]&quot;;.
+        ///            // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
+        ///            // TODO: set large fields to null.
+        ///
+        ///            disposedValue = true;
+        ///       [rest of string was truncated]&quot;;.
         /// </summary>
         internal static string DisposePattern {
             get {

src/Features/CSharp/CSharpFeaturesResources.resx

@@ -257,40 +257,40 @@
   </data>
   <data name="DisposePattern" xml:space="preserve">
     <value>
-#region IDisposable Support
-private bool disposedValue = false; // To detect redundant calls
+    #region IDisposable Support
+    private bool disposedValue = false; // To detect redundant calls
 
-{0}void Dispose(bool disposing)
-{{
-    if (!disposedValue)
+    {0}void Dispose(bool disposing)
     {{
-        if (disposing)
+        if (!disposedValue)
         {{
-            // TODO: dispose managed state (managed objects).
+            if (disposing)
+            {{
+                // TODO: dispose managed state (managed objects).
+            }}
+
+            // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
+            // TODO: set large fields to null.
+
+            disposedValue = true;
         }}
- 
-        // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
-        // TODO: set large fields to null.
- 
-        disposedValue = true;
     }}
-}}
 
-// TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
-// ~{1}() {{
-//   // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
-//   Dispose(false);
-// }}
- 
-// This code added to correctly implement the disposable pattern.
-{2}Dispose()
-{{
-    // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
-    Dispose(true);
-    // TODO: uncomment the following line if the finalizer is overridden above.
-    // GC.SuppressFinalize(this);
-}}
-#endregion</value>
+    // TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
+    // ~{1}() {{
+    //   // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
+    //   Dispose(false);
+    // }}
+
+    // This code added to correctly implement the disposable pattern.
+    {2}Dispose()
+    {{
+        // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
+        Dispose(true);
+        // TODO: uncomment the following line if the finalizer is overridden above.
+        // GC.SuppressFinalize(this);
+    }}
+    #endregion</value>
   </data>
   <data name="AutoselectDisabledDueToPotentialImplicitArray" xml:space="preserve">
     <value>Autoselect disabled due to potential implicit array creation.</value>

src/Workspaces/CSharpTest/CodeGeneration/SyntaxGeneratorTests.cs

@@ -647,10 +647,18 @@ public void TestPropertyDeclarations()
                 _g.PropertyDeclaration("p", _g.IdentifierName("x"), modifiers: DeclarationModifiers.Abstract | DeclarationModifiers.ReadOnly),
                 "abstract x p\r\n{\r\n    get;\r\n}");
 
+            VerifySyntax<PropertyDeclarationSyntax>(
+                _g.PropertyDeclaration("p", _g.IdentifierName("x"), modifiers: DeclarationModifiers.Abstract | DeclarationModifiers.WriteOnly),
+                "abstract x p\r\n{\r\n    set;\r\n}");
+
             VerifySyntax<PropertyDeclarationSyntax>(
                 _g.PropertyDeclaration("p", _g.IdentifierName("x"), modifiers: DeclarationModifiers.ReadOnly),
                 "x p\r\n{\r\n    get\r\n    {\r\n    }\r\n}");
 
+            VerifySyntax<PropertyDeclarationSyntax>(
+                _g.PropertyDeclaration("p", _g.IdentifierName("x"), modifiers: DeclarationModifiers.WriteOnly),
+                "x p\r\n{\r\n    set\r\n    {\r\n    }\r\n}");
+
             VerifySyntax<PropertyDeclarationSyntax>(
                 _g.PropertyDeclaration("p", _g.IdentifierName("x"), modifiers: DeclarationModifiers.Abstract),
                 "abstract x p\r\n{\r\n    get;\r\n    set;\r\n}");
@@ -659,6 +667,10 @@ public void TestPropertyDeclarations()
                 _g.PropertyDeclaration("p", _g.IdentifierName("x"), modifiers: DeclarationModifiers.ReadOnly, getAccessorStatements: new[] { _g.IdentifierName("y") }),
                 "x p\r\n{\r\n    get\r\n    {\r\n        y;\r\n    }\r\n}");
 
+            VerifySyntax<PropertyDeclarationSyntax>(
+                _g.PropertyDeclaration("p", _g.IdentifierName("x"), modifiers: DeclarationModifiers.WriteOnly, setAccessorStatements: new[] { _g.IdentifierName("y") }),
+                "x p\r\n{\r\n    set\r\n    {\r\n        y;\r\n    }\r\n}");
+
             VerifySyntax<PropertyDeclarationSyntax>(
                 _g.PropertyDeclaration("p", _g.IdentifierName("x"), setAccessorStatements: new[] { _g.IdentifierName("y") }),
                 "x p\r\n{\r\n    get\r\n    {\r\n    }\r\n\r\n    set\r\n    {\r\n        y;\r\n    }\r\n}");
@@ -671,6 +683,10 @@ public void TestIndexerDeclarations()
                 _g.IndexerDeclaration(new[] { _g.ParameterDeclaration("z", _g.IdentifierName("y")) }, _g.IdentifierName("x"), modifiers: DeclarationModifiers.Abstract | DeclarationModifiers.ReadOnly),
                 "abstract x this[y z]\r\n{\r\n    get;\r\n}");
 
+            VerifySyntax<IndexerDeclarationSyntax>(
+                _g.IndexerDeclaration(new[] { _g.ParameterDeclaration("z", _g.IdentifierName("y")) }, _g.IdentifierName("x"), modifiers: DeclarationModifiers.Abstract | DeclarationModifiers.WriteOnly),
+                "abstract x this[y z]\r\n{\r\n    set;\r\n}");
+
             VerifySyntax<IndexerDeclarationSyntax>(
                 _g.IndexerDeclaration(new[] { _g.ParameterDeclaration("z", _g.IdentifierName("y")) }, _g.IdentifierName("x"), modifiers: DeclarationModifiers.Abstract),
                 "abstract x this[y z]\r\n{\r\n    get;\r\n    set;\r\n}");
@@ -679,11 +695,20 @@ public void TestIndexerDeclarations()
                 _g.IndexerDeclaration(new[] { _g.ParameterDeclaration("z", _g.IdentifierName("y")) }, _g.IdentifierName("x"), modifiers: DeclarationModifiers.ReadOnly),
                 "x this[y z]\r\n{\r\n    get\r\n    {\r\n    }\r\n}");
 
+            VerifySyntax<IndexerDeclarationSyntax>(
+                _g.IndexerDeclaration(new[] { _g.ParameterDeclaration("z", _g.IdentifierName("y")) }, _g.IdentifierName("x"), modifiers: DeclarationModifiers.WriteOnly),
+                "x this[y z]\r\n{\r\n    set\r\n    {\r\n    }\r\n}");
+
             VerifySyntax<IndexerDeclarationSyntax>(
                 _g.IndexerDeclaration(new[] { _g.ParameterDeclaration("z", _g.IdentifierName("y")) }, _g.IdentifierName("x"), modifiers: DeclarationModifiers.ReadOnly,
                     getAccessorStatements: new[] { _g.IdentifierName("a") }),
                 "x this[y z]\r\n{\r\n    get\r\n    {\r\n        a;\r\n    }\r\n}");
 
+            VerifySyntax<IndexerDeclarationSyntax>(
+                _g.IndexerDeclaration(new[] { _g.ParameterDeclaration("z", _g.IdentifierName("y")) }, _g.IdentifierName("x"), modifiers: DeclarationModifiers.WriteOnly,
+                    setAccessorStatements: new[] { _g.IdentifierName("a") }),
+                "x this[y z]\r\n{\r\n    set\r\n    {\r\n        a;\r\n    }\r\n}");
+
             VerifySyntax<IndexerDeclarationSyntax>(
                 _g.IndexerDeclaration(new[] { _g.ParameterDeclaration("z", _g.IdentifierName("y")) }, _g.IdentifierName("x")),
                 "x this[y z]\r\n{\r\n    get\r\n    {\r\n    }\r\n\r\n    set\r\n    {\r\n    }\r\n}");
@@ -1179,7 +1204,7 @@ public class C { } // end").Members[0];
             VerifySyntax<ClassDeclarationSyntax>(removed, "// comment\r\npublic class C\r\n{\r\n} // end\r\n");
 
             var attrWithComment = _g.GetAttributes(added).First();
-            VerifySyntax<AttributeListSyntax>(attrWithComment, "// comment\r\n[a]\r\n");
+            VerifySyntax<AttributeListSyntax>(attrWithComment, "// comment\r\n[a]");
 
             // added attributes are stripped of trivia
             var added2 = _g.AddAttributes(cls, attrWithComment);
@@ -1740,6 +1765,59 @@ public void TestWithExpression()
             Assert.Null(_g.GetExpression(_g.WithExpression(_g.IdentifierName("e"), _g.IdentifierName("x"))));
         }
 
+        [Fact]
+        public void TestAccessorDeclarations()
+        {
+            var prop = _g.PropertyDeclaration("p", _g.IdentifierName("T"));
+
+            Assert.Equal(2, _g.GetAccessors(prop).Count);
+
+            // get accessors from property
+            var getAccessor = _g.GetAccessor(prop, DeclarationKind.GetAccessor);
+            Assert.NotNull(getAccessor);
+            VerifySyntax<AccessorDeclarationSyntax>(getAccessor,
+@"get
+{
+}");
+
+            Assert.NotNull(getAccessor);
+            Assert.Equal(Accessibility.NotApplicable, _g.GetAccessibility(getAccessor));
+
+            // get accessors from property
+            var setAccessor = _g.GetAccessor(prop, DeclarationKind.SetAccessor);
+            Assert.NotNull(setAccessor);
+            Assert.Equal(Accessibility.NotApplicable, _g.GetAccessibility(setAccessor));
+
+            // remove accessors
+            Assert.Null(_g.GetAccessor(_g.RemoveNode(prop, getAccessor), DeclarationKind.GetAccessor));
+            Assert.Null(_g.GetAccessor(_g.RemoveNode(prop, setAccessor), DeclarationKind.SetAccessor));
+
+            // change accessor accessibility
+            Assert.Equal(Accessibility.Public, _g.GetAccessibility(_g.WithAccessibility(getAccessor, Accessibility.Public)));
+            Assert.Equal(Accessibility.Private, _g.GetAccessibility(_g.WithAccessibility(setAccessor, Accessibility.Private)));
+
+            // change accessor statements
+            Assert.Equal(0, _g.GetStatements(getAccessor).Count);
+            Assert.Equal(0, _g.GetStatements(setAccessor).Count);
+
+            var newGetAccessor = _g.WithStatements(getAccessor, null);
+            VerifySyntax<AccessorDeclarationSyntax>(newGetAccessor,
+@"get;");
+
+            var newNewGetAccessor = _g.WithStatements(newGetAccessor, new SyntaxNode[] { });
+            VerifySyntax<AccessorDeclarationSyntax>(newNewGetAccessor,
+@"get
+{
+}");
+
+            // change accessors
+            var newProp = _g.ReplaceNode(prop, getAccessor, _g.WithAccessibility(getAccessor, Accessibility.Public));
+            Assert.Equal(Accessibility.Public, _g.GetAccessibility(_g.GetAccessor(newProp, DeclarationKind.GetAccessor)));
+
+            newProp = _g.ReplaceNode(prop, setAccessor, _g.WithAccessibility(setAccessor, Accessibility.Public));
+            Assert.Equal(Accessibility.Public, _g.GetAccessibility(_g.GetAccessor(newProp, DeclarationKind.SetAccessor)));
+        }
+
         [Fact]
         public void TestGetStatements()
         {

src/Workspaces/Core/Portable/Editing/DeclarationKind.cs

@@ -30,6 +30,11 @@ public enum DeclarationKind
         Parameter,
         Variable,
         Attribute,
-        LambdaExpression
+        LambdaExpression,
+        GetAccessor,
+        SetAccessor,
+        AddAccessor,
+        RemoveAccessor,
+        RaiseAccessor
     }
 }

src/Workspaces/Core/Portable/Editing/DeclarationModifiers.cs

@@ -26,7 +26,8 @@ private DeclarationModifiers(Modifiers modifiers)
             bool isConst = false,
             bool isWithEvents = false,
             bool isPartial = false,
-            bool isAsync = false)
+            bool isAsync = false,
+            bool isWriteOnly = false)
             : this(
                   (isStatic ? Modifiers.Static : Modifiers.None) |
                   (isAbstract ? Modifiers.Abstract : Modifiers.None) |
@@ -120,6 +121,11 @@ public bool IsAsync
             get { return (_modifiers & Modifiers.Async) != 0; }
         }
 
+        public bool IsWriteOnly
+        {
+            get { return (_modifiers & Modifiers.WriteOnly) != 0; }
+        }
+
         public DeclarationModifiers WithIsStatic(bool isStatic)
         {
             return new DeclarationModifiers(SetFlag(_modifiers, Modifiers.Static, isStatic));
@@ -180,6 +186,11 @@ public DeclarationModifiers WithAsync(bool isAsync)
             return new DeclarationModifiers(SetFlag(_modifiers, Modifiers.Async, isAsync));
         }
 
+        public DeclarationModifiers WithIsWriteOnly(bool isWriteOnly)
+        {
+            return new DeclarationModifiers(SetFlag(_modifiers, Modifiers.WriteOnly, isWriteOnly));
+        }
+
         private static Modifiers SetFlag(Modifiers existing, Modifiers modifier, bool isSet)
         {
             return isSet ? (existing | modifier) : (existing & ~modifier);
@@ -200,7 +211,8 @@ private enum Modifiers
             Const = 0x0100,
             WithEvents = 0x0200,
             Partial = 0x0400,
-            Async = 0x0800
+            Async = 0x0800,
+            WriteOnly = 0x1000
         }
 
         public static readonly DeclarationModifiers None = default(DeclarationModifiers);
@@ -217,6 +229,7 @@ private enum Modifiers
         public static readonly DeclarationModifiers WithEvents = new DeclarationModifiers(Modifiers.WithEvents);
         public static readonly DeclarationModifiers Partial = new DeclarationModifiers(Modifiers.Partial);
         public static readonly DeclarationModifiers Async = new DeclarationModifiers(Modifiers.Async);
+        public static readonly DeclarationModifiers WriteOnly = new DeclarationModifiers(Modifiers.WriteOnly);
 
         public static DeclarationModifiers operator |(DeclarationModifiers left, DeclarationModifiers right)
         {

src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs

@@ -901,6 +901,32 @@ public SyntaxNode AddParameters(SyntaxNode declaration, IEnumerable<SyntaxNode>
         /// </summary>
         public abstract SyntaxNode WithStatements(SyntaxNode declaration, IEnumerable<SyntaxNode> statements);
 
+        /// <summary>
+        /// Gets the accessors for the declaration.
+        /// </summary>
+        public abstract IReadOnlyList<SyntaxNode> GetAccessors(SyntaxNode declaration);
+
+        /// <summary>
+        /// Gets the accessor of the specified kind for the declaration.
+        /// </summary>
+        public SyntaxNode GetAccessor(SyntaxNode declaration, DeclarationKind kind)
+        {
+            return this.GetAccessors(declaration).FirstOrDefault(a => GetDeclarationKind(a) == kind);
+        }
+
+        /// <summary>
+        /// Creates a new instance of the declaration with the accessors inserted.
+        /// </summary>
+        public abstract SyntaxNode InsertAccessors(SyntaxNode declaration, int index, IEnumerable<SyntaxNode> accessors);
+
+        /// <summary>
+        /// Creates a new instance of the declaration with the accessors added.
+        /// </summary>
+        public SyntaxNode AddAccessors(SyntaxNode declaration, IEnumerable<SyntaxNode> accessors)
+        {
+            return this.InsertAccessors(declaration, this.GetAccessors(declaration).Count, accessors);
+        }
+
         /// <summary>
         /// Gets the statements for the body of the get-accessor of the declaration.
         /// </summary>

src/Workspaces/Core/Portable/PublicAPI.txt

@@ -170,6 +170,7 @@ Microsoft.CodeAnalysis.DocumentInfo.WithName(string name)
 Microsoft.CodeAnalysis.DocumentInfo.WithSourceCodeKind(Microsoft.CodeAnalysis.SourceCodeKind kind)
 Microsoft.CodeAnalysis.DocumentInfo.WithTextLoader(Microsoft.CodeAnalysis.TextLoader loader)
 Microsoft.CodeAnalysis.Editing.DeclarationKind
+Microsoft.CodeAnalysis.Editing.DeclarationKind.AddAccessor = 26
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Attribute = 22
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Class = 2
 Microsoft.CodeAnalysis.Editing.DeclarationKind.CompilationUnit = 1
@@ -182,6 +183,7 @@ Microsoft.CodeAnalysis.Editing.DeclarationKind.Enum = 5
 Microsoft.CodeAnalysis.Editing.DeclarationKind.EnumMember = 15
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Event = 16
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Field = 12
+Microsoft.CodeAnalysis.Editing.DeclarationKind.GetAccessor = 24
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Indexer = 14
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Interface = 4
 Microsoft.CodeAnalysis.Editing.DeclarationKind.LambdaExpression = 23
@@ -192,6 +194,9 @@ Microsoft.CodeAnalysis.Editing.DeclarationKind.None = 0
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Operator = 8
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Parameter = 20
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Property = 13
+Microsoft.CodeAnalysis.Editing.DeclarationKind.RaiseAccessor = 28
+Microsoft.CodeAnalysis.Editing.DeclarationKind.RemoveAccessor = 27
+Microsoft.CodeAnalysis.Editing.DeclarationKind.SetAccessor = 25
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Struct = 3
 Microsoft.CodeAnalysis.Editing.DeclarationKind.Variable = 21
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers
@@ -208,6 +213,7 @@ Microsoft.CodeAnalysis.Editing.DeclarationModifiers.IsStatic.get
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.IsUnsafe.get
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.IsVirtual.get
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.IsWithEvents.get
+Microsoft.CodeAnalysis.Editing.DeclarationModifiers.IsWriteOnly.get
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithAsync(bool isAsync)
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithIsAbstract(bool isAbstract)
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithIsConst(bool isConst)
@@ -218,6 +224,7 @@ Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithIsSealed(bool isSealed)
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithIsStatic(bool isStatic)
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithIsUnsafe(bool isUnsafe)
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithIsVirtual(bool isVirtual)
+Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithIsWriteOnly(bool isWriteOnly)
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithPartial(bool isPartial)
 Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithWithEvents(bool withEvents)
 Microsoft.CodeAnalysis.Editing.DocumentEditor
@@ -266,6 +273,7 @@ Microsoft.CodeAnalysis.Editing.SyntaxEditor.SyntaxEditor(Microsoft.CodeAnalysis.
 Microsoft.CodeAnalysis.Editing.SyntaxEditor.TrackNode(Microsoft.CodeAnalysis.SyntaxNode node)
 Microsoft.CodeAnalysis.Editing.SyntaxEditorExtensions
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator
+Microsoft.CodeAnalysis.Editing.SyntaxGenerator.AddAccessors(Microsoft.CodeAnalysis.SyntaxNode declaration, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> accessors)
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator.AddAttributeArguments(Microsoft.CodeAnalysis.SyntaxNode attributeDeclaration, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> attributeArguments)
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator.AddAttributes(Microsoft.CodeAnalysis.SyntaxNode declaration, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> attributes)
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator.AddAttributes(Microsoft.CodeAnalysis.SyntaxNode declaration, params Microsoft.CodeAnalysis.SyntaxNode[] attributes)
@@ -299,6 +307,7 @@ Microsoft.CodeAnalysis.Editing.SyntaxGenerator.FieldDeclaration(Microsoft.CodeAn
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GenericName(string identifier, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ITypeSymbol> typeArguments)
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GenericName(string identifier, params Microsoft.CodeAnalysis.ITypeSymbol[] typeArguments)
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GenericName(string identifier, params Microsoft.CodeAnalysis.SyntaxNode[] typeArguments)
+Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetAccessor(Microsoft.CodeAnalysis.SyntaxNode declaration, Microsoft.CodeAnalysis.Editing.DeclarationKind kind)
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetDeclaration(Microsoft.CodeAnalysis.SyntaxNode node)
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetDeclaration(Microsoft.CodeAnalysis.SyntaxNode node, Microsoft.CodeAnalysis.Editing.DeclarationKind kind)
 Microsoft.CodeAnalysis.Editing.SyntaxGenerator.IfStatement(Microsoft.CodeAnalysis.SyntaxNode condition, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> trueStatements, Microsoft.CodeAnalysis.SyntaxNode falseStatement)
@@ -873,6 +882,7 @@ abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.ExpressionStatement(Micr
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.FieldDeclaration(string name, Microsoft.CodeAnalysis.SyntaxNode type, Microsoft.CodeAnalysis.Accessibility accessibility = Microsoft.CodeAnalysis.Accessibility.NotApplicable, Microsoft.CodeAnalysis.Editing.DeclarationModifiers modifiers = default(Microsoft.CodeAnalysis.Editing.DeclarationModifiers), Microsoft.CodeAnalysis.SyntaxNode initializer = null)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GenericName(string identifier, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> typeArguments)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetAccessibility(Microsoft.CodeAnalysis.SyntaxNode declaration)
+abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetAccessors(Microsoft.CodeAnalysis.SyntaxNode declaration)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetAttributeArguments(Microsoft.CodeAnalysis.SyntaxNode attributeDeclaration)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetAttributes(Microsoft.CodeAnalysis.SyntaxNode declaration)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetBaseAndInterfaceTypes(Microsoft.CodeAnalysis.SyntaxNode declaration)
@@ -893,6 +903,7 @@ abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GreaterThanOrEqualExpres
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.IdentifierName(string identifier)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.IfStatement(Microsoft.CodeAnalysis.SyntaxNode condition, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> trueStatements, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> falseStatements = null)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.IndexerDeclaration(System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> parameters, Microsoft.CodeAnalysis.SyntaxNode type, Microsoft.CodeAnalysis.Accessibility accessibility = Microsoft.CodeAnalysis.Accessibility.NotApplicable, Microsoft.CodeAnalysis.Editing.DeclarationModifiers modifiers = default(Microsoft.CodeAnalysis.Editing.DeclarationModifiers), System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> getAccessorStatements = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> setAccessorStatements = null)
+abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.InsertAccessors(Microsoft.CodeAnalysis.SyntaxNode declaration, int index, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> accessors)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.InsertAttributeArguments(Microsoft.CodeAnalysis.SyntaxNode attributeDeclaration, int index, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> attributeArguments)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.InsertAttributes(Microsoft.CodeAnalysis.SyntaxNode declaration, int index, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> attributes)
 abstract Microsoft.CodeAnalysis.Editing.SyntaxGenerator.InsertMembers(Microsoft.CodeAnalysis.SyntaxNode declaration, int index, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.SyntaxNode> members)
@@ -1193,6 +1204,7 @@ static readonly Microsoft.CodeAnalysis.Editing.DeclarationModifiers.Static
 static readonly Microsoft.CodeAnalysis.Editing.DeclarationModifiers.Unsafe
 static readonly Microsoft.CodeAnalysis.Editing.DeclarationModifiers.Virtual
 static readonly Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WithEvents
+static readonly Microsoft.CodeAnalysis.Editing.DeclarationModifiers.WriteOnly
 static readonly Microsoft.CodeAnalysis.Formatting.Formatter.Annotation
 static readonly Microsoft.CodeAnalysis.Formatting.FormattingOptions.IndentationSize
 static readonly Microsoft.CodeAnalysis.Formatting.FormattingOptions.NewLine

src/Workspaces/Core/Portable/Shared/Utilities/BitArrayUtilities.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System;
-using System.Collections;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.Shared.Utilities
-{
-    internal static class BitArrayUtilities
-    {
-        private const string SerializationFormat = "0";
-
-        public static void WriteTo(this BitArray bitArray, ObjectWriter writer)
-        {
-            // Our serialization format doesn't round-trip bit arrays of non-byte lengths
-            Contract.ThrowIfTrue(bitArray.Length % 8 != 0);
-
-            writer.WriteString(SerializationFormat);
-            writer.WriteInt32(bitArray.Length / 8);
-
-            // This will hold the byte that we will write out after we process every 8 bits. This is
-            // LSB, so we push bits into it from the MSB.
-            byte b = 0;
-
-            for (var i = 0; i < bitArray.Length; i++)
-            {
-                if (bitArray[i])
-                {
-                    b = (byte)(0x80 | b >> 1);
-                }
-                else
-                {
-                    b >>= 1;
-                }
-
-                if ((i + 1) % 8 == 0)
-                {
-                    // End of a byte, write out the byte
-                    writer.WriteByte(b);
-                }
-            }
-        }
-
-        public static BitArray ReadFrom(this ObjectReader reader)
-        {
-            var version = reader.ReadString();
-            if (!string.Equals(version, SerializationFormat, StringComparison.Ordinal))
-            {
-                return null;
-            }
-
-            // TODO: find a way to use pool
-            var length = reader.ReadInt32();
-            var bytes = new byte[length];
-
-            for (var i = 0; i < bytes.Length; i++)
-            {
-                bytes[i] = reader.ReadByte();
-            }
-
-            return new BitArray(bytes);
-        }
-    }
-}

src/Workspaces/Core/Portable/Shared/Utilities/BloomFilter_Serialization.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Collections;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Shared.Utilities
@@ -14,7 +15,37 @@ public void WriteTo(ObjectWriter writer)
             writer.WriteString(SerializationFormat);
             writer.WriteBoolean(_isCaseSensitive);
             writer.WriteInt32(_hashFunctionCount);
-            _bitArray.WriteTo(writer);
+            WriteBitArray(writer, _bitArray);
+        }
+
+        private static void WriteBitArray(ObjectWriter writer, BitArray bitArray)
+        {
+            // Our serialization format doesn't round-trip bit arrays of non-byte lengths
+            Contract.ThrowIfTrue(bitArray.Length % 8 != 0);
+
+            writer.WriteInt32(bitArray.Length / 8);
+
+            // This will hold the byte that we will write out after we process every 8 bits. This is
+            // LSB, so we push bits into it from the MSB.
+            byte b = 0;
+
+            for (var i = 0; i < bitArray.Length; i++)
+            {
+                if (bitArray[i])
+                {
+                    b = (byte)(0x80 | b >> 1);
+                }
+                else
+                {
+                    b >>= 1;
+                }
+
+                if ((i + 1) % 8 == 0)
+                {
+                    // End of a byte, write out the byte
+                    writer.WriteByte(b);
+                }
+            }
         }
 
         public static BloomFilter ReadFrom(ObjectReader reader)
@@ -27,13 +58,22 @@ public static BloomFilter ReadFrom(ObjectReader reader)
 
             var isCaseSensitive = reader.ReadBoolean();
             int hashFunctionCount = reader.ReadInt32();
-            var bitArray = BitArrayUtilities.ReadFrom(reader);
-            if (bitArray == null)
+            var bitArray = ReadBitArray(reader);
+            return new BloomFilter(bitArray, hashFunctionCount, isCaseSensitive);
+        }
+
+        private static BitArray ReadBitArray(ObjectReader reader)
+        {
+            // TODO: find a way to use pool
+            var length = reader.ReadInt32();
+            var bytes = new byte[length];
+
+            for (var i = 0; i < bytes.Length; i++)
             {
-                return null;
+                bytes[i] = reader.ReadByte();
             }
 
-            return new BloomFilter(bitArray, hashFunctionCount, isCaseSensitive);
+            return new BitArray(bytes);
         }
     }
 }

src/Workspaces/Core/Portable/Workspaces.csproj

@@ -693,7 +693,6 @@
     <Compile Include="Shared\Extensions\TextSpanExtensions.cs" />
     <Compile Include="Shared\NormalizedTextSpanCollection.cs" />
     <Compile Include="Shared\Utilities\AliasSymbolCache.cs" />
-    <Compile Include="Shared\Utilities\BitArrayUtilities.cs" />
     <Compile Include="Shared\Utilities\BloomFilter.cs" />
     <Compile Include="Shared\Utilities\BloomFilter_Serialization.cs" />
     <Compile Include="Shared\Utilities\CommonFormattingHelpers.cs" />

src/Workspaces/VisualBasicTest/CodeGeneration/SyntaxGeneratorTests.vb

@@ -688,6 +688,10 @@ End Function</x>.Value)
                 g.PropertyDeclaration("p", g.IdentifierName("x"), modifiers:=DeclarationModifiers.Abstract + DeclarationModifiers.ReadOnly),
 <x>MustInherit ReadOnly Property p As x</x>.Value)
 
+            VerifySyntax(Of PropertyStatementSyntax)(
+                g.PropertyDeclaration("p", g.IdentifierName("x"), modifiers:=DeclarationModifiers.Abstract + DeclarationModifiers.WriteOnly),
+<x>MustInherit WriteOnly Property p As x</x>.Value)
+
             VerifySyntax(Of PropertyBlockSyntax)(
                 g.PropertyDeclaration("p", g.IdentifierName("x"), modifiers:=DeclarationModifiers.ReadOnly),
 <x>ReadOnly Property p As x
@@ -695,6 +699,13 @@ End Function</x>.Value)
     End Get
 End Property</x>.Value)
 
+            VerifySyntax(Of PropertyBlockSyntax)(
+                g.PropertyDeclaration("p", g.IdentifierName("x"), modifiers:=DeclarationModifiers.WriteOnly),
+<x>WriteOnly Property p As x
+    Set(value As x)
+    End Set
+End Property</x>.Value)
+
             VerifySyntax(Of PropertyStatementSyntax)(
                 g.PropertyDeclaration("p", g.IdentifierName("x"), modifiers:=DeclarationModifiers.Abstract),
 <x>MustInherit Property p As x</x>.Value)
@@ -707,6 +718,14 @@ End Property</x>.Value)
     End Get
 End Property</x>.Value)
 
+            VerifySyntax(Of PropertyBlockSyntax)(
+                g.PropertyDeclaration("p", g.IdentifierName("x"), modifiers:=DeclarationModifiers.WriteOnly, setAccessorStatements:={g.IdentifierName("y")}),
+<x>WriteOnly Property p As x
+    Set(value As x)
+        y
+    End Set
+End Property</x>.Value)
+
             VerifySyntax(Of PropertyBlockSyntax)(
                 g.PropertyDeclaration("p", g.IdentifierName("x"), setAccessorStatements:={g.IdentifierName("y")}),
 <x>Property p As x
@@ -725,6 +744,10 @@ End Property</x>.Value)
                 g.IndexerDeclaration({g.ParameterDeclaration("z", g.IdentifierName("y"))}, g.IdentifierName("x"), modifiers:=DeclarationModifiers.Abstract + DeclarationModifiers.ReadOnly),
 <x>Default MustInherit ReadOnly Property Item(z As y) As x</x>.Value)
 
+            VerifySyntax(Of PropertyStatementSyntax)(
+                g.IndexerDeclaration({g.ParameterDeclaration("z", g.IdentifierName("y"))}, g.IdentifierName("x"), modifiers:=DeclarationModifiers.Abstract + DeclarationModifiers.WriteOnly),
+<x>Default MustInherit WriteOnly Property Item(z As y) As x</x>.Value)
+
             VerifySyntax(Of PropertyStatementSyntax)(
                 g.IndexerDeclaration({g.ParameterDeclaration("z", g.IdentifierName("y"))}, g.IdentifierName("x"), modifiers:=DeclarationModifiers.Abstract),
 <x>Default MustInherit Property Item(z As y) As x</x>.Value)
@@ -736,6 +759,13 @@ End Property</x>.Value)
     End Get
 End Property</x>.Value)
 
+            VerifySyntax(Of PropertyBlockSyntax)(
+                g.IndexerDeclaration({g.ParameterDeclaration("z", g.IdentifierName("y"))}, g.IdentifierName("x"), modifiers:=DeclarationModifiers.WriteOnly),
+<x>Default WriteOnly Property Item(z As y) As x
+    Set(value As x)
+    End Set
+End Property</x>.Value)
+
             VerifySyntax(Of PropertyBlockSyntax)(
                 g.IndexerDeclaration({g.ParameterDeclaration("z", g.IdentifierName("y"))}, g.IdentifierName("x"), modifiers:=DeclarationModifiers.ReadOnly,
                     getAccessorStatements:={g.IdentifierName("a")}),
@@ -745,6 +775,15 @@ End Property</x>.Value)
     End Get
 End Property</x>.Value)
 
+            VerifySyntax(Of PropertyBlockSyntax)(
+                g.IndexerDeclaration({g.ParameterDeclaration("z", g.IdentifierName("y"))}, g.IdentifierName("x"), modifiers:=DeclarationModifiers.WriteOnly,
+                    setAccessorStatements:={g.IdentifierName("a")}),
+<x>Default WriteOnly Property Item(z As y) As x
+    Set(value As x)
+        a
+    End Set
+End Property</x>.Value)
+
             VerifySyntax(Of PropertyBlockSyntax)(
                 g.IndexerDeclaration({g.ParameterDeclaration("z", g.IdentifierName("y"))}, g.IdentifierName("x"), modifiers:=DeclarationModifiers.None),
 <x>Default Property Item(z As y) As x
@@ -1682,8 +1721,7 @@ End Class ' end</x>.Value)
             VerifySyntax(Of AttributeListSyntax)(
                 attrWithComment,
 <x>' comment
-&lt;a&gt;
-</x>.Value)
+&lt;a&gt;</x>.Value)
 
             ' added attributes are stripped of trivia
             Dim added2 = g.AddAttributes(cls, attrWithComment)
@@ -2151,6 +2189,53 @@ End Sub</x>.Value)
 End Function</x>.Value)
         End Sub
 
+        <Fact>
+        Public Sub TestAccessorDeclarations()
+            Dim _g = g
+            Dim prop = _g.PropertyDeclaration("p", _g.IdentifierName("T"))
+
+            Assert.Equal(2, _g.GetAccessors(prop).Count)
+
+            ' get accessors from property
+            Dim getAccessor = _g.GetAccessor(prop, DeclarationKind.GetAccessor)
+            Assert.NotNull(getAccessor)
+            VerifySyntax(Of AccessorBlockSyntax)(getAccessor,
+<x>Get
+End Get</x>.Value)
+
+            Assert.NotNull(getAccessor)
+            Assert.Equal(Accessibility.NotApplicable, _g.GetAccessibility(getAccessor))
+
+            ' get accessors from property
+            Dim setAccessor = _g.GetAccessor(prop, DeclarationKind.SetAccessor)
+            Assert.NotNull(setAccessor)
+            Assert.Equal(Accessibility.NotApplicable, _g.GetAccessibility(setAccessor))
+
+            ' remove accessors
+            Assert.Null(_g.GetAccessor(_g.RemoveNode(prop, getAccessor), DeclarationKind.GetAccessor))
+            Assert.Null(_g.GetAccessor(_g.RemoveNode(prop, setAccessor), DeclarationKind.SetAccessor))
+
+            ' change accessor accessibility
+            Assert.Equal(Accessibility.Public, _g.GetAccessibility(_g.WithAccessibility(getAccessor, Accessibility.Public)))
+            Assert.Equal(Accessibility.Private, _g.GetAccessibility(_g.WithAccessibility(setAccessor, Accessibility.Private)))
+
+            ' change accessor statements
+            Assert.Equal(0, _g.GetStatements(getAccessor).Count)
+            Assert.Equal(0, _g.GetStatements(setAccessor).Count)
+
+            Dim newGetAccessor = _g.WithStatements(getAccessor, Nothing)
+            VerifySyntax(Of AccessorBlockSyntax)(newGetAccessor,
+<x>Get
+End Get</x>.Value)
+
+            ' change accessors
+            Dim newProp = _g.ReplaceNode(prop, getAccessor, _g.WithAccessibility(getAccessor, Accessibility.Public))
+            Assert.Equal(Accessibility.Public, _g.GetAccessibility(_g.GetAccessor(newProp, DeclarationKind.GetAccessor)))
+
+            newProp = _g.ReplaceNode(prop, setAccessor, _g.WithAccessibility(setAccessor, Accessibility.Public))
+            Assert.Equal(Accessibility.Public, _g.GetAccessibility(_g.GetAccessor(newProp, DeclarationKind.SetAccessor)))
+        End Sub
+
         <Fact>
         Public Sub TestGetAccessorStatements()
             Dim stmts = {g.ExpressionStatement(g.AssignmentStatement(g.IdentifierName("x"), g.IdentifierName("y"))), g.ExpressionStatement(g.InvocationExpression(g.IdentifierName("fn"), g.IdentifierName("arg")))}