Merge pull request #3609 from IvenBach/Rubberduck.SmartIndenter_C#6&7_Update

retailcoder · web-flow · commit ae19b667fe1c · 2017-12-14T07:44:42.000-05:00
C#6/C#7 technical debt payment
diff --git a/Rubberduck.SmartIndenter/AbsoluteCodeLine.cs b/Rubberduck.SmartIndenter/AbsoluteCodeLine.cs
@@ -94,9 +94,9 @@ private void ExtractEndOfLineComment()
             EndOfLineComment = match.Groups["comment"].Value.Trim();
         }
 
-        public AbsoluteCodeLine Previous { get; private set; }
+        public AbsoluteCodeLine Previous { get; }
 
-        public string Original { get; private set; }
+        public string Original { get; }
 
         public string Escaped
         {
@@ -120,58 +120,46 @@ public string Escaped
 
         public string EndOfLineComment { get; private set; }
 
-        public IEnumerable<string> Segments
-        {
-            get { return _segments; }
-        }
+        public IEnumerable<string> Segments => _segments;
 
         public string ContinuationRebuildText
         {
             get
             {
-                var output = (_code + " " + EndOfLineComment).Trim();
+                var output = ($"{_code} {EndOfLineComment}").Trim();
                 return HasContinuation ? output.Substring(0, output.Length - 1) : output;
             }
         }
 
-        public bool ContainsOnlyComment
-        {
-            get { return _code.StartsWith("'") || _code.StartsWith("Rem "); }
-        }
+        public bool ContainsOnlyComment => _code.StartsWith("'") || _code.StartsWith("Rem ");
 
-        public bool IsDeclaration
-        {
-            get { return !IsEmpty && (!IsProcedureStart && !ProcedureStartIgnoreRegex.IsMatch(_code)) && DeclarationRegex.IsMatch(_code); }
-        }
+        public bool IsDeclaration => !IsEmpty && (!IsProcedureStart && !ProcedureStartIgnoreRegex.IsMatch(_code)) && DeclarationRegex.IsMatch(_code);
 
         public bool IsDeclarationContinuation { get; set; }
 
         public bool HasDeclarationContinuation
         {
             get
             {
-                return (!IsProcedureStart && !ProcedureStartIgnoreRegex.IsMatch(_code)) &&
-                       !ContainsOnlyComment &&
-                       string.IsNullOrEmpty(EndOfLineComment) &&
-                       HasContinuation &&
-                       ((IsDeclarationContinuation && Segments.Count() == 1) || DeclarationRegex.IsMatch(Segments.Last()));
+                if (!string.IsNullOrEmpty(EndOfLineComment)
+                        || ContainsOnlyComment
+                        || IsProcedureStart
+                        || !HasContinuation
+                        || ProcedureStartIgnoreRegex.IsMatch(_code))
+                {
+                    return false;
+                }
+
+                return (IsDeclarationContinuation && Segments.Count() == 1)
+                        || DeclarationRegex.IsMatch(Segments.Last());
             }
         }
 
-        public bool HasContinuation
-        {
-            get { return _code.Equals("_") || _code.EndsWith(" _") || EndOfLineComment.EndsWith(" _"); }
-        }
+        public bool HasContinuation => _code.Equals("_") || _code.EndsWith(" _") || EndOfLineComment.EndsWith(" _");
 
-        public bool IsPrecompilerDirective
-        {
-            get { return _code.TrimStart().StartsWith("#"); }
-        }
+        public bool IsPrecompilerDirective => _code.TrimStart().StartsWith("#");
 
-        public bool IsBareDebugStatement
-        {
-            get { return _code.StartsWith("Debug.") || _code.Equals("Stop"); }
-        }
+        public bool IsBareDebugStatement => _code.StartsWith("Debug.") || _code.Equals("Stop");
 
         public int EnumOrTypeStarts
         {
@@ -185,19 +173,15 @@ public int EnumOrTypeEnds
 
         public bool IsProcedureStart
         {
-            get
-            { return _segments.Any(s => ProcedureStartRegex.IsMatch(s)) && !_segments.Any(s => ProcedureStartIgnoreRegex.IsMatch(s)); }
+            get { return _segments.Any(s => ProcedureStartRegex.IsMatch(s)) && !_segments.Any(s => ProcedureStartIgnoreRegex.IsMatch(s)); }
         }
 
         public bool IsProcedureEnd
         {
             get { return _segments.Any(s => ProcedureEndRegex.IsMatch(s)); }
         }
 
-        public bool IsEmpty
-        {
-            get { return Original.Trim().Length == 0; }
-        }
+        public bool IsEmpty => Original.Trim().Length == 0;
 
         public int NextLineIndents
         {
@@ -301,7 +285,7 @@ private void AlignDims(int postition)
         {
             if (_segments[0].Trim().StartsWith("As "))
             {
-                _segments[0] = string.Format("{0}{1}", new String(' ', _settings.AlignDimColumn - postition - 1), _segments[0].Trim());
+                _segments[0] = string.Format("{0}{1}", new string(' ', _settings.AlignDimColumn - postition - 1), _segments[0].Trim());
                 return;
             }
             var alignTokens = _segments[0].Split(new[] { " As " }, StringSplitOptions.None);
diff --git a/Rubberduck.SmartIndenter/AlignmentToken.cs b/Rubberduck.SmartIndenter/AlignmentToken.cs
@@ -10,8 +10,8 @@ internal enum AlignmentTokenType
 
     internal class AlignmentToken
     {
-        public AlignmentTokenType Type { get; private set; }
-        public int Position { get; private set; }
+        public AlignmentTokenType Type { get; }
+        public int Position { get; }
 
         public AlignmentToken(AlignmentTokenType type, int position)
         {
diff --git a/Rubberduck.SmartIndenter/IndenterProgressEventArgs.cs b/Rubberduck.SmartIndenter/IndenterProgressEventArgs.cs
@@ -4,30 +4,17 @@ namespace Rubberduck.SmartIndenter
 {
     public class IndenterProgressEventArgs : EventArgs
     {
-        private readonly int _progress;
-        private readonly int _max;
-        private readonly string _componentName;
-
         public IndenterProgressEventArgs(string componentName, int progress, int max)
         {
-            _progress = progress;
-            _max = max;
-            _componentName = componentName;
+            Progress = progress;
+            Max = max;
+            ComponentName = componentName;
         }
 
-        public int Progress
-        {
-            get { return _progress; }
-        }
+        public int Progress { get; }
 
-        public string ComponentName
-        {
-            get { return _componentName; }
-        }
+        public string ComponentName { get; }
 
-        public int Max
-        {
-            get { return _max; }
-        }
+        public int Max { get; }
     }
 }
diff --git a/Rubberduck.SmartIndenter/IndenterSettings.cs b/Rubberduck.SmartIndenter/IndenterSettings.cs
@@ -29,41 +29,35 @@ public class IndenterSettings : IIndenterSettings, IEquatable<IndenterSettings>
         private int _dimAlignment;
         public virtual int AlignDimColumn
         {
-            get { return _dimAlignment; }
-            set
-            {
-                _dimAlignment = value > MaximumAlignDimColumn ? MaximumAlignDimColumn : Math.Max(value, 0);
-            }
+            get => _dimAlignment;
+            set => _dimAlignment = value > MaximumAlignDimColumn ? MaximumAlignDimColumn : Math.Max(value, 0);
         }
 
         public virtual EndOfLineCommentStyle EndOfLineCommentStyle { get; set; }
 
         private int _commentAlignment;
         public virtual int EndOfLineCommentColumnSpaceAlignment
         {
-            get { return _commentAlignment; }
-            set
-            {
-                _commentAlignment = value > MaximumEndOfLineCommentColumnSpaceAlignment
-                    ? MaximumEndOfLineCommentColumnSpaceAlignment
-                    : value;
-            }
+            get => _commentAlignment;
+            set => _commentAlignment = value > MaximumEndOfLineCommentColumnSpaceAlignment
+                ? MaximumEndOfLineCommentColumnSpaceAlignment
+                : value;
         }
 
         private int _indentSpaces;
         public virtual int IndentSpaces
         {
-            get { return _indentSpaces; }
-            set { _indentSpaces = value > MaximumIndentSpaces ? MaximumIndentSpaces : Math.Max(value, 0); }
+            get => _indentSpaces;
+            set => _indentSpaces = value > MaximumIndentSpaces ? MaximumIndentSpaces : Math.Max(value, 0);
         }
 
         public virtual bool VerticallySpaceProcedures { get; set; }
 
         private int _procedureSpacing;
         public virtual int LinesBetweenProcedures
         {
-            get { return _procedureSpacing; }
-            set { _procedureSpacing = value > MaximumVerticalSpacing ? MaximumVerticalSpacing : Math.Max(value, 0); }
+            get => _procedureSpacing;
+            set => _procedureSpacing = value > MaximumVerticalSpacing ? MaximumVerticalSpacing : Math.Max(value, 0);
         }
 
         public IndenterSettings()
diff --git a/Rubberduck.SmartIndenter/StringLiteralAndBracketEscaper.cs b/Rubberduck.SmartIndenter/StringLiteralAndBracketEscaper.cs
@@ -14,13 +14,13 @@ internal class StringLiteralAndBracketEscaper
 
         private readonly List<string> _strings = new List<string>();
         private readonly List<string> _brackets = new List<string>();
-        private readonly string _unescaped;
-        private readonly string _escaped;
 
-        public string EscapedString { get { return _escaped; } }
-        public string OriginalString { get { return _unescaped; } } 
-        public IEnumerable<string> EscapedStrings { get { return _strings; } }
-        public IEnumerable<string> EscapedBrackets { get { return _brackets; } }
+        public string EscapedString { get; }
+
+        public string OriginalString { get; }
+
+        public IEnumerable<string> EscapedStrings => _strings;
+        public IEnumerable<string> EscapedBrackets => _brackets;
 
         public string UnescapeIndented(string indented)
         {
@@ -38,9 +38,9 @@ public string UnescapeIndented(string indented)
 
         public StringLiteralAndBracketEscaper(string code)
         {
-            _unescaped = code;
+            OriginalString = code;
 
-            var chars = _unescaped.ToCharArray();
+            var chars = OriginalString.ToCharArray();
             var quoted = false;
             var bracketed = false;
             var ins = 0;
@@ -88,7 +88,7 @@ public StringLiteralAndBracketEscaper(string code)
                     }
                 }
             }
-            _escaped = new string(chars);
+            EscapedString = new string(chars);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -94,9 +94,9 @@ private void ExtractEndOfLineComment()`
`94`	`94`	`EndOfLineComment = match.Groups["comment"].Value.Trim();`
`95`	`95`	`}`
`96`	`96`
`97`		`- public AbsoluteCodeLine Previous { get; private set; }`
	`97`	`+ public AbsoluteCodeLine Previous { get; }`
`98`	`98`
`99`		`- public string Original { get; private set; }`
	`99`	`+ public string Original { get; }`
`100`	`100`
`101`	`101`	`public string Escaped`
`102`	`102`	`{`
`@@ -120,58 +120,46 @@ public string Escaped`
`120`	`120`
`121`	`121`	`public string EndOfLineComment { get; private set; }`
`122`	`122`
`123`		`- public IEnumerable<string> Segments`
`124`		`- {`
`125`		`- get { return _segments; }`
`126`		`- }`
	`123`	`+ public IEnumerable<string> Segments => _segments;`
`127`	`124`
`128`	`125`	`public string ContinuationRebuildText`
`129`	`126`	`{`
`130`	`127`	`get`
`131`	`128`	`{`
`132`		`- var output = (_code + " " + EndOfLineComment).Trim();`
	`129`	`+ var output = ($"{_code} {EndOfLineComment}").Trim();`
`133`	`130`	`return HasContinuation ? output.Substring(0, output.Length - 1) : output;`
`134`	`131`	`}`
`135`	`132`	`}`
`136`	`133`
`137`		`- public bool ContainsOnlyComment`
`138`		`- {`
`139`		`- get { return _code.StartsWith("'") \|\| _code.StartsWith("Rem "); }`
`140`		`- }`
	`134`	`+ public bool ContainsOnlyComment => _code.StartsWith("'") \|\| _code.StartsWith("Rem ");`
`141`	`135`
`142`		`- public bool IsDeclaration`
`143`		`- {`
`144`		`- get { return !IsEmpty && (!IsProcedureStart && !ProcedureStartIgnoreRegex.IsMatch(_code)) && DeclarationRegex.IsMatch(_code); }`
`145`		`- }`
	`136`	`+ public bool IsDeclaration => !IsEmpty && (!IsProcedureStart && !ProcedureStartIgnoreRegex.IsMatch(_code)) && DeclarationRegex.IsMatch(_code);`
`146`	`137`
`147`	`138`	`public bool IsDeclarationContinuation { get; set; }`
`148`	`139`
`149`	`140`	`public bool HasDeclarationContinuation`
`150`	`141`	`{`
`151`	`142`	`get`
`152`	`143`	`{`
`153`		`- return (!IsProcedureStart && !ProcedureStartIgnoreRegex.IsMatch(_code)) &&`
`154`		`- !ContainsOnlyComment &&`
`155`		`- string.IsNullOrEmpty(EndOfLineComment) &&`
`156`		`- HasContinuation &&`
`157`		`- ((IsDeclarationContinuation && Segments.Count() == 1) \|\| DeclarationRegex.IsMatch(Segments.Last()));`
	`144`	`+ if (!string.IsNullOrEmpty(EndOfLineComment)`
	`145`	`+ \|\| ContainsOnlyComment`
	`146`	`+ \|\| IsProcedureStart`
	`147`	`+ \|\| !HasContinuation`
	`148`	`+ \|\| ProcedureStartIgnoreRegex.IsMatch(_code))`
	`149`	`+ {`
	`150`	`+ return false;`
	`151`	`+ }`
	`152`	`+`
	`153`	`+ return (IsDeclarationContinuation && Segments.Count() == 1)`
	`154`	`+ \|\| DeclarationRegex.IsMatch(Segments.Last());`
`158`	`155`	`}`
`159`	`156`	`}`
`160`	`157`
`161`		`- public bool HasContinuation`
`162`		`- {`
`163`		`- get { return _code.Equals("_") \|\| _code.EndsWith(" _") \|\| EndOfLineComment.EndsWith(" _"); }`
`164`		`- }`
	`158`	`+ public bool HasContinuation => _code.Equals("_") \|\| _code.EndsWith(" _") \|\| EndOfLineComment.EndsWith(" _");`
`165`	`159`
`166`		`- public bool IsPrecompilerDirective`
`167`		`- {`
`168`		`- get { return _code.TrimStart().StartsWith("#"); }`
`169`		`- }`
	`160`	`+ public bool IsPrecompilerDirective => _code.TrimStart().StartsWith("#");`
`170`	`161`
`171`		`- public bool IsBareDebugStatement`
`172`		`- {`
`173`		`- get { return _code.StartsWith("Debug.") \|\| _code.Equals("Stop"); }`
`174`		`- }`
	`162`	`+ public bool IsBareDebugStatement => _code.StartsWith("Debug.") \|\| _code.Equals("Stop");`
`175`	`163`
`176`	`164`	`public int EnumOrTypeStarts`
`177`	`165`	`{`
`@@ -185,19 +173,15 @@ public int EnumOrTypeEnds`
`185`	`173`
`186`	`174`	`public bool IsProcedureStart`
`187`	`175`	`{`
`188`		`- get`
`189`		`- { return _segments.Any(s => ProcedureStartRegex.IsMatch(s)) && !_segments.Any(s => ProcedureStartIgnoreRegex.IsMatch(s)); }`
	`176`	`+ get { return _segments.Any(s => ProcedureStartRegex.IsMatch(s)) && !_segments.Any(s => ProcedureStartIgnoreRegex.IsMatch(s)); }`
`190`	`177`	`}`
`191`	`178`
`192`	`179`	`public bool IsProcedureEnd`
`193`	`180`	`{`
`194`	`181`	`get { return _segments.Any(s => ProcedureEndRegex.IsMatch(s)); }`
`195`	`182`	`}`
`196`	`183`
`197`		`- public bool IsEmpty`
`198`		`- {`
`199`		`- get { return Original.Trim().Length == 0; }`
`200`		`- }`
	`184`	`+ public bool IsEmpty => Original.Trim().Length == 0;`
`201`	`185`
`202`	`186`	`public int NextLineIndents`
`203`	`187`	`{`
`@@ -301,7 +285,7 @@ private void AlignDims(int postition)`
`301`	`285`	`{`
`302`	`286`	`if (_segments[0].Trim().StartsWith("As "))`
`303`	`287`	`{`
`304`		`- _segments[0] = string.Format("{0}{1}", new String(' ', _settings.AlignDimColumn - postition - 1), _segments[0].Trim());`
	`288`	`+ _segments[0] = string.Format("{0}{1}", new string(' ', _settings.AlignDimColumn - postition - 1), _segments[0].Trim());`
`305`	`289`	`return;`
`306`	`290`	`}`
`307`	`291`	`var alignTokens = _segments[0].Split(new[] { " As " }, StringSplitOptions.None);`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@ internal enum AlignmentTokenType`
`10`	`10`
`11`	`11`	`internal class AlignmentToken`
`12`	`12`	`{`
`13`		`- public AlignmentTokenType Type { get; private set; }`
`14`		`- public int Position { get; private set; }`
	`13`	`+ public AlignmentTokenType Type { get; }`
	`14`	`+ public int Position { get; }`
`15`	`15`
`16`	`16`	`public AlignmentToken(AlignmentTokenType type, int position)`
`17`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,30 +4,17 @@ namespace Rubberduck.SmartIndenter`
`4`	`4`	`{`
`5`	`5`	`public class IndenterProgressEventArgs : EventArgs`
`6`	`6`	`{`
`7`		`- private readonly int _progress;`
`8`		`- private readonly int _max;`
`9`		`- private readonly string _componentName;`
`10`		`-`
`11`	`7`	`public IndenterProgressEventArgs(string componentName, int progress, int max)`
`12`	`8`	`{`
`13`		`- _progress = progress;`
`14`		`- _max = max;`
`15`		`- _componentName = componentName;`
	`9`	`+ Progress = progress;`
	`10`	`+ Max = max;`
	`11`	`+ ComponentName = componentName;`
`16`	`12`	`}`
`17`	`13`
`18`		`- public int Progress`
`19`		`- {`
`20`		`- get { return _progress; }`
`21`		`- }`
	`14`	`+ public int Progress { get; }`
`22`	`15`
`23`		`- public string ComponentName`
`24`		`- {`
`25`		`- get { return _componentName; }`
`26`		`- }`
	`16`	`+ public string ComponentName { get; }`
`27`	`17`
`28`		`- public int Max`
`29`		`- {`
`30`		`- get { return _max; }`
`31`		`- }`
	`18`	`+ public int Max { get; }`
`32`	`19`	`}`
`33`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,13 +14,13 @@ internal class StringLiteralAndBracketEscaper`
`14`	`14`
`15`	`15`	`private readonly List<string> _strings = new List<string>();`
`16`	`16`	`private readonly List<string> _brackets = new List<string>();`
`17`		`- private readonly string _unescaped;`
`18`		`- private readonly string _escaped;`
`19`	`17`
`20`		`- public string EscapedString { get { return _escaped; } }`
`21`		`- public string OriginalString { get { return _unescaped; } }`
`22`		`- public IEnumerable<string> EscapedStrings { get { return _strings; } }`
`23`		`- public IEnumerable<string> EscapedBrackets { get { return _brackets; } }`
	`18`	`+ public string EscapedString { get; }`
	`19`	`+`
	`20`	`+ public string OriginalString { get; }`
	`21`	`+`
	`22`	`+ public IEnumerable<string> EscapedStrings => _strings;`
	`23`	`+ public IEnumerable<string> EscapedBrackets => _brackets;`
`24`	`24`
`25`	`25`	`public string UnescapeIndented(string indented)`
`26`	`26`	`{`
`@@ -38,9 +38,9 @@ public string UnescapeIndented(string indented)`
`38`	`38`
`39`	`39`	`public StringLiteralAndBracketEscaper(string code)`
`40`	`40`	`{`
`41`		`- _unescaped = code;`
	`41`	`+ OriginalString = code;`
`42`	`42`
`43`		`- var chars = _unescaped.ToCharArray();`
	`43`	`+ var chars = OriginalString.ToCharArray();`
`44`	`44`	`var quoted = false;`
`45`	`45`	`var bracketed = false;`
`46`	`46`	`var ins = 0;`
`@@ -88,7 +88,7 @@ public StringLiteralAndBracketEscaper(string code)`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`}`
`91`		`- _escaped = new string(chars);`
	`91`	`+ EscapedString = new string(chars);`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`	`}`