started updating examples to use CDATA, and formalized examples/example/text/code structure.

Author: retailcoder

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignedByValParameterInspection.cs

@@ -18,24 +18,30 @@ namespace Rubberduck.Inspections.Concrete
     /// Mutating the inputs destroys the initial state, and makes the intent ambiguous: if the calling code is meant
     /// to be able to access the modified values, then the parameter should be passed ByRef; the ByVal modifier might be a bug.
     /// </why>
+    /// <examples>
     /// <example>
-    /// This inspection means to flag the following examples:
+    /// <text>This inspection means to flag the following examples:</text>
     /// <code>
+    /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Long)
     ///     foo = foo + 1 ' is the caller supposed to see the updated value?
     ///     Debug.Print foo
-    /// End Sub
+    /// End Sub]]>
     /// </code>
-    /// The following code should not trip this inspection:
+    /// </example>
+    /// <example>
+    /// <text>The following code should not trip this inspection:</text>
     /// <code>
+    /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Long)
     ///     Dim bar As Long
     ///     bar = foo
     ///     bar = bar + 1 ' clearly a local copy of the original value.
     ///     Debug.Print bar
-    /// End Sub
+    /// End Sub]]>
     /// </code>
     /// </example>
+    /// </examples>
     public sealed class AssignedByValParameterInspection : InspectionBase
     {
         public AssignedByValParameterInspection(RubberduckParserState state)

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs

@@ -18,24 +18,30 @@ namespace Rubberduck.Inspections.Concrete
     /// <why>
     /// The first assignment is likely redundant, since it is being overwritten by the second.
     /// </why>
+    /// <examples>
     /// <example>
-    /// This inspection means to flag the following examples:
+    /// <text>This inspection means to flag the following examples:</text>
     /// <code>
+    /// <![CDATA[
     /// Public Sub DoSomething()
     ///     Dim foo As Long
     ///     foo = 12 ' assignment is redundant
     ///     foo = 34 
-    /// End Sub
+    /// End Sub]]>
     /// </code>
-    /// The following code should not trip this inspection:
+    /// </example>
+    /// <example>
+    /// <text>The following code should not trip this inspection:</text>
     /// <code>
+    /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Long)
     ///     Dim bar As Long
     ///     bar = 12
     ///     bar = bar + foo ' variable is re-assigned, but the prior assigned value is read at least once first.
-    /// End Sub
+    /// End Sub]]>
     /// </code>
     /// </example>
+    /// </examples>
     public sealed class AssignmentNotUsedInspection : InspectionBase
     {
         private readonly Walker _walker;

Rubberduck.CodeAnalysis/Inspections/Concrete/AttributeValueOutOfSyncInspection.cs

@@ -20,24 +20,30 @@ namespace Rubberduck.Inspections.Concrete
     /// Keeping Rubberduck annotation comments in sync with the hidden VB attribute values, surfaces these hidden attributes in the VBE code panes; 
     /// Rubberduck can rewrite the attributes to match the corresponding annotation comment.
     /// </why>
+    /// <examples>
     /// <example>
-    /// This inspection means to flag the following examples (code from an exported module):
+    /// <text>This inspection means to flag the following examples (code from an exported module):</text>
     /// <code>
+    /// <![CDATA[
     /// '@Description("foo")
     /// Public Sub DoSomething()
     /// Attribute VB_Description = "bar"
     ///     ' ...
-    /// End Sub
+    /// End Sub]]>
     /// </code>
-    /// The following code should not trip this inspection:
+    /// </example>
+    /// <example>
+    /// <text>The following code should not trip this inspection:</text>
     /// <code>
+    /// <![CDATA[
     /// '@Description("foo")
     /// Public Sub DoSomething()
     /// Attribute VB_Description = "foo"
     ///     ' ...
-    /// End Sub
+    /// End Sub]]>
     /// </code>
     /// </example>
+    /// </examples>
     [CannotAnnotate]
     public sealed class AttributeValueOutOfSyncInspection : InspectionBase
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/BooleanAssignedInIfElseInspection.cs

@@ -19,24 +19,30 @@ namespace Rubberduck.Inspections.Concrete
     /// <why>
     /// A Boolean expression never needs to be compared to a Boolean literal in a conditional expression.
     /// </why>
+    /// <examples>
     /// <example>
-    /// This inspection means to flag the following examples:
+    /// <text>This inspection means to flag the following examples:</text>
     /// <code>
+    /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Boolean)
     ///     If foo = True Then ' foo is known to already be a Boolean value.
     ///         ' ...
     ///     End If
-    /// End Sub
+    /// End Sub]]>
     /// </code>
-    /// The following code should not trip this inspection:
+    /// </example>
+    /// <example>
+    /// <text>The following code should not trip this inspection:</text>
     /// <code>
+    /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Boolean)
     ///     If foo Then
     ///         ' ...
     ///     End If
-    /// End Sub
+    /// End Sub]]>
     /// </code>
     /// </example>
+    /// </examples>
     public sealed class BooleanAssignedInIfElseInspection : ParseTreeInspectionBase
     {
         public BooleanAssignedInIfElseInspection(RubberduckParserState state)

Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ApplicationWorksheetFunctionInspection.cs

@@ -27,9 +27,10 @@ namespace Rubberduck.Inspections.Concrete
     /// Trying to compare or assign a <c>Variant/Error</c> to another data type will throw error 13 "type mismatch" at run-time. 
     /// Consider using the early-bound equivalent function instead.
     /// </why>
+    /// <examples>
     /// <example>
-    /// This inspection means to flag the following example late-bound WorksheetFunction calls:
-    /// <code>
+    /// <text>This inspection means to flag the following example late-bound WorksheetFunction calls:</text>
+    /// <code><![CDATA[
     /// Private Sub Example()
     ///     Debug.Print Application.Sum(Array(1, 2, 3), 4, 5, "ABC") ' outputs "Error 2015"
     /// 
@@ -39,10 +40,11 @@ namespace Rubberduck.Inspections.Concrete
     ///     If Application.Sum(Array(1, 2, 3), 4, 5, "ABC") > 15 Then
     ///         ' won't run, error 13 "type mismatch" will be thrown when Variant/Error is compared to an Integer.
     ///     End If
-    /// End Sub
-    /// </code>
-    /// The following early-bound WorksheetFunction calls should not trip this inspection. Note the consistent error, thrown at the same point every time:
-    /// <code>
+    /// End Sub]]></code>
+    /// </example>
+    /// <example>
+    /// <text>The following early-bound WorksheetFunction calls should not trip this inspection. Note the consistent error, thrown at the same point every time:</text>
+    /// <code><![CDATA[
     /// Private Sub Example()
     ///     Debug.Print Application.WorksheetFunction.Sum(Array(1, 2, 3), 4, 5, "ABC") ' throws error 1004
     /// 
@@ -52,9 +54,9 @@ namespace Rubberduck.Inspections.Concrete
     ///     If Application.WorksheetFunction.Sum(Array(1, 2, 3), 4, 5, "ABC") > 15 Then ' throws error 1004
     ///         ' won't run, error 1004 is thrown when "ABC" is processed by WorksheetFunction.Sum, before it returns.
     ///     End If
-    /// End Sub
-    /// </code>
+    /// End Sub]]></code>
     /// </example>
+    /// </examples>
     [RequiredLibrary("Excel")]
     public class ApplicationWorksheetFunctionInspection : InspectionBase
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ExcelMemberMayReturnNothingInspection.cs

@@ -19,29 +19,33 @@ namespace Rubberduck.Inspections.Concrete
     /// Range.Find methods return a Range object reference that refers to the cell containing the search string;
     /// this object reference will be Nothing if the search didn't turn up any results, and a member call against Nothing will raise run-time error 91.
     /// </why>
+    /// <examples>
     /// <example>
-    /// This inspection means to flag the following example Range.Find member calls:
-    /// <code>
+    /// <text>This inspection means to flag the following example Range.Find member calls:</text>
+    /// <code><![CDATA[
     /// Private Sub Example()
     ///     Dim foo As Range
     ///     Set foo = Sheet1.Range("A:A").Find("Test") ' foo is Nothing if there are no results
     ///     MsgBox foo.Address ' Range.Address member call should be flagged.
     /// 
     ///     Dim rowIndex As Range
     ///     rowIndex = Sheet1.Range("A:A").Find("Test").Row ' Range.Row member call should be flagged.
-    /// End Sub
+    /// End Sub]]>
     /// </code>
-    /// The following Range.Find calls should not trip this inspection.
-    /// <code>
+    /// </example>
+    /// <example>
+    /// <text>The following Range.Find calls should not trip this inspection.</text>
+    /// <code><![CDATA[
     /// Private Sub Example()
     ///     Dim foo As Range
     ///     Set foo = Sheet1.Range("A:A").Find("Test")
     ///     If Not foo Is Nothing Then
     ///         MsgBox foo.Address ' Range.Address member call is safe.
     ///     End If
-    /// End Sub
+    /// End Sub]]>
     /// </code>
     /// </example>
+    /// </examples>
     [RequiredLibrary("Excel")]
     public class ExcelMemberMayReturnNothingInspection : MemberAccessMayReturnNothingInspectionBase
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ExcelUdfNameIsValidCellReferenceInspection.cs

@@ -23,18 +23,20 @@ namespace Rubberduck.Inspections.Inspections.Concrete
     /// Another good reason to avoid numeric suffixes: if the function is meant to be used as a UDF in a cell formula,
     /// the worksheet cell by the same name takes precedence and gets the reference, and the function is never invoked.
     /// </why>
+    /// <examples>
     /// <example>
-    /// This inspection will flag the following function name as a valid cell address:
-    /// <code>
+    /// <text>This inspection will flag the following function name as a valid cell address:</text>
+    /// <code><![CDATA[
     /// Public Function FOO1234()
-    /// End Sub
+    /// End Sub]]>
     /// </code>
-    /// The following funcrtion name should not trip this inspection.
-    /// <code>
+    /// <text>The following function name should not trip this inspection:</text>
+    /// <code><![CDATA[
     /// Public Function Foo()
-    /// End Sub
+    /// End Sub]]>
     /// </code>
     /// </example>
+    /// </examples>
 
     [RequiredLibrary("Excel")]
     public class ExcelUdfNameIsValidCellReferenceInspection : InspectionBase

Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ImplicitActiveSheetReferenceInspection.cs

@@ -22,24 +22,30 @@ namespace Rubberduck.Inspections.Concrete
     /// is more robust, and will be less likely to throw run-time error 1004 or produce unexpected results
     /// when the active sheet isn't the expected one.
     /// </why>
+    /// <examples>
     /// <example>
-    /// This inspection means to flag the following example unqualified Worksheet.Cells member calls:
+    /// <text>This inspection means to flag the following example unqualified Worksheet.Cells member calls:</text>
     /// <code>
+    /// <![CDATA[
     /// Private Sub Example()
     ///     Dim foo As Range
     ///     Set foo = Sheet1.Range(Cells(1, 1), Cells(1, 10)) ' Worksheet.Cells implicitly from ActiveSheet; error 1004 if that isn't Sheet1.
-    /// End Sub
+    /// End Sub]]>
     /// </code>
-    /// The following qualified Worksheet.Cells member calls should not trip this inspection.
+    /// </example>
+    /// <example>
+    /// <text>The following qualified Worksheet.Cells member calls should not trip this inspection.</text>
     /// <code>
+    /// <![CDATA[
     /// Private Sub Example()
     ///     Dim foo As Range
     ///     With Sheet1
     ///         Set foo = .Range(.Cells(1, 1), .Cells(1, 10)) ' all member calls are made against the With block object
     ///     End With
-    /// End Sub
+    /// End Sub]]>
     /// </code>
     /// </example>
+    /// </examples>
     [RequiredLibrary("Excel")]
     public sealed class ImplicitActiveSheetReferenceInspection : InspectionBase
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/ImplicitActiveWorkbookReferenceInspection.cs

@@ -23,22 +23,28 @@ namespace Rubberduck.Inspections.Concrete
     /// is more robust, and will be less likely to throw run-time error 1004 or produce unexpected results
     /// when the active workbook isn't the expected one.
     /// </why>
+    /// <examples>
     /// <example>
-    /// This inspection means to flag the following example unqualified Workbook.Worksheets member calls:
+    /// <text>This inspection means to flag the following example unqualified Workbook.Worksheets member calls:</text>
     /// <code>
+    /// <![CDATA[
     /// Private Sub Example()
     ///     Dim summarySheet As Worksheet
     ///     Set summarySheet = Worksheets("Summary") ' unqualified Worksheets is implicitly querying the active workbook's Worksheets collection.
-    /// End Sub
+    /// End Sub]]>
     /// </code>
-    /// The following qualified Workbook.Worksheets member calls should not trip this inspection.
+    /// </example>
+    /// <example>
+    /// <text>The following qualified Workbook.Worksheets member calls should not trip this inspection.</text>
     /// <code>
+    /// <![CDATA[
     /// Private Sub Example(ByVal book As Workbook)
     ///     Dim summarySheet As Worksheet
     ///     Set summarySheet = book.Worksheets("Summary")
-    /// End Sub
+    /// End Sub]]>
     /// </code>
     /// </example>
+    /// </examples>
     [RequiredLibrary("Excel")]
     public sealed class ImplicitActiveWorkbookReferenceInspection : InspectionBase
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/Excel/SheetAccessedUsingStringInspection.cs

@@ -28,22 +28,28 @@ namespace Rubberduck.Inspections.Concrete
     /// <remarks>
     /// Inspection only evaluates hard-coded string literals; string-valued expressions evaluating into a sheet name are ignored.
     /// </remarks>
+    /// <examples>
     /// <example>
-    /// This inspection means to flag the following:
+    /// <text>This inspection means to flag the following:</text>
     /// <code>
+    /// <![CDATA[
     /// Public Sub DoSomething()
     ///     Dim sheet As Worksheet
     ///     Set sheet = ThisWorkbook.Worksheets("Sheet1") ' Sheet "Sheet1" exists at compile-time
     ///     sheet.Range("A1").Value = 42
-    /// End Sub
+    /// End Sub]]>
     /// </code>
-    /// The following code should not trip this inspection:
+    /// </example>
+    /// <example>
+    /// <text>The following code should not trip this inspection:</text>
     /// <code>
+    /// <![CDATA[
     /// Public Sub DoSomething()
     ///     Sheet1.Range("A1").Value = 42 ' TODO rename Sheet1 to meaningful name
-    /// End Sub
+    /// End Sub]]>
     /// </code>
     /// </example>
+    /// </examples>
     [RequiredHost("EXCEL.EXE")]
     [RequiredLibrary("Excel")]
     public class SheetAccessedUsingStringInspection : InspectionBase