Add missing module elements to inspection xml-doc examples

Also makes this mandatory from now on.

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/ArgumentWithIncompatibleObjectTypeInspection.cs

@@ -18,23 +18,24 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// The VBA compiler does not check whether different object types are compatible. Instead there is a runtime error whenever the types are incompatible.
     /// </why>
     /// <example hasresult="true">
+    /// <module name="Interface" type="Class Module">
     /// <![CDATA[
     /// IInterface:
     ///
     /// Public Sub DoSomething()
     /// End Sub
-    ///
-    /// ------------------------------
-    /// Class1:
-    ///
-    ///'No Implements IInterface
+    /// ]]>
+    /// </module>
+    /// <module name="Class1" type="Class Module">
+    /// <![CDATA[
+    /// 'No Implements IInterface
     /// 
     /// Public Sub DoSomething()
     /// End Sub
-    ///
-    /// ------------------------------
-    /// Module1:
-    /// 
+    /// ]]>
+    /// </module>
+    /// <module name="Module1" type="Standard Module">
+    /// <![CDATA[
     /// Public Sub DoIt()
     ///     Dim cls As Class1
     ///     Set cls = New Class1
@@ -44,25 +45,27 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// Public Sub Foo(cls As IInterface)
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasresult="false">
+    /// <module name="Interface" type="Class Module">
     /// <![CDATA[
     /// IInterface:
     ///
     /// Public Sub DoSomething()
     /// End Sub
-    ///
-    /// ------------------------------
-    /// Class1:
-    ///
+    /// ]]>
+    /// </module>
+    /// <module name="Class1" type="Class Module">
+    /// <![CDATA[
     /// Implements IInterface
     /// 
-    /// Private Sub IInterface_DoSomething()
+    /// Public Sub DoSomething()
     /// End Sub
-    ///
-    /// ------------------------------
-    /// Module1:
-    /// 
+    /// ]]>
+    /// </module>
+    /// <module name="Module1" type="Standard Module">
+    /// <![CDATA[
     /// Public Sub DoIt()
     ///     Dim cls As Class1
     ///     Set cls = New Class1
@@ -72,6 +75,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// Public Sub Foo(cls As IInterface)
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal class ArgumentWithIncompatibleObjectTypeInspection : ArgumentReferenceInspectionFromDeclarationsBase<string>
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignedByValParameterInspection.cs

@@ -16,14 +16,17 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// to be able to access the modified values, then the parameter should be passed ByRef; the ByVal modifier might be a bug.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![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
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Long)
     ///     Dim bar As Long
@@ -32,6 +35,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     ///     Debug.Print bar
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal sealed class AssignedByValParameterInspection : DeclarationInspectionBase
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs

@@ -20,22 +20,26 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// The first assignment is likely redundant, since it is being overwritten by the second.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething()
     ///     Dim foo As Long
     ///     foo = 12 ' assignment is redundant
     ///     foo = 34 
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
     /// <![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
     /// ]]>
+    /// </module>
     /// </example>
     internal sealed class AssignmentNotUsedInspection : IdentifierReferenceInspectionBase
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/AttributeValueOutOfSyncInspection.cs

@@ -19,22 +19,26 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// Rubberduck can rewrite the attributes to match the corresponding annotation comment.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// '@Description("foo")
     /// Public Sub DoSomething()
     /// Attribute VB_Description = "bar"
     ///     ' ...
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// '@Description("foo")
     /// Public Sub DoSomething()
     /// Attribute VB_Description = "foo"
     ///     ' ...
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     [CannotAnnotate]
     internal sealed class AttributeValueOutOfSyncInspection : DeclarationInspectionMultiResultBase<(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList<string> AttributeValues)>

Rubberduck.CodeAnalysis/Inspections/Concrete/BooleanAssignedInIfElseInspection.cs

@@ -14,6 +14,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// The assignment could be made directly to the result of the conditional Boolean expression instead.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal value As Long)
     ///     Dim result As Boolean
@@ -25,15 +26,18 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     ///     Debug.Print result
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal value As Long)
     ///     Dim result As Boolean
     ///     result = value > 10
     ///     Debug.Print result
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal sealed class BooleanAssignedInIfElseInspection : ParseTreeInspectionBase<VBAParser.IfStmtContext>
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/ConstantNotUsedInspection.cs

@@ -15,22 +15,26 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// Declarations that are never used should be removed.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Private Const foo As Long = 42
     ///
     /// Public Sub DoSomething()
     ///     ' no reference to 'foo' anywhere...
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Private Const foo As Long = 42
     ///
     /// Public Sub DoSomething()
     ///     Debug.Print foo
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal sealed class ConstantNotUsedInspection : DeclarationInspectionBase
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/DefTypeStatementInspection.cs

@@ -15,6 +15,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// These declarative statements make the first letter of identifiers determine the data type.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// DefBool B
     /// DefDbl D
@@ -24,6 +25,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     ///     ' ...
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal sealed class DefTypeStatementInspection : ParseTreeInspectionBase<VBAParser.DefTypeContext>
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/DefaultMemberRequiredInspection.cs

@@ -15,42 +15,42 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// The VBA compiler does not check whether the necessary default member is present. Instead there is a runtime error whenever the runtime type fails to have the default member.
     /// </why>
     /// <example hasresult="true">
+    /// <module name="Class1" type="Class Module">
     /// <![CDATA[
-    /// Class1:
-    ///
     /// Public Function Foo(index As Long) As Long
     /// 'No default member attribute
     /// End Function
-    ///
-    /// ------------------------------
-    /// Module1:
-    /// 
+    /// ]]>
+    /// </module>
+    /// <module name="Module1" type="Standard Module">
+    /// <![CDATA[
     /// Public Sub DoIt()
     ///     Dim cls As Class1
     ///     Dim bar As Variant
     ///     Set cls = New Class1
     ///     bar = cls(0) 
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasresult="false">
+    /// <module name="Class1" type="Class Module">
     /// <![CDATA[
-    /// Class1:
-    ///
     /// Public Function Foo(index As Long) As Long
     /// Attribute Foo.UserMemId = 0
     /// End Function
-    ///
-    /// ------------------------------
-    /// Module1:
-    /// 
+    /// ]]>
+    /// </module>
+    /// <module name="Module1" type="Standard Module">
+    /// <![CDATA[
     /// Public Sub DoIt()
     ///     Dim cls As Class1
     ///     Dim bar As Variant
     ///     Set cls = New Class1
     ///     bar = cls(0) 
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal class DefaultMemberRequiredInspection : IdentifierReferenceInspectionBase
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/DuplicatedAnnotationInspection.cs

@@ -16,6 +16,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// Rubberduck annotations should not be specified more than once for a given module, member, variable, or expression.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// '@Folder("Bar")
     /// '@Folder("Foo")
@@ -24,15 +25,18 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     ///     ' ...
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// '@Folder("Foo.Bar")
     ///
     /// Public Sub DoSomething()
     ///     ' ...
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal sealed class DuplicatedAnnotationInspection : DeclarationInspectionMultiResultBase<IAnnotation>
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/EmptyBlock/EmptyCaseBlockInspection.cs

@@ -14,6 +14,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete.EmptyBlock
     /// Case blocks in VBA do not "fall through"; an empty 'Case' block might be hiding a bug.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Long)
     ///     Select Case foo
@@ -23,8 +24,10 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete.EmptyBlock
     ///     End Select
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Long)
     ///     Select Case foo
@@ -35,6 +38,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete.EmptyBlock
     ///     End Select
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal sealed class EmptyCaseBlockInspection : EmptyBlockInspectionBase<VBAParser.CaseClauseContext>
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/EmptyBlock/EmptyDoWhileBlockInspection.cs

@@ -14,22 +14,26 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete.EmptyBlock
     /// Dead code should be removed. A loop without a body is usually redundant.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Long)
     ///     Do
     ///         ' no executable statement...
     ///     Loop While foo < 100
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Long)
     ///     Do
     ///         Debug.Print foo
     ///     Loop While foo < 100
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal sealed class EmptyDoWhileBlockInspection : EmptyBlockInspectionBase<VBAParser.DoLoopStmtContext>
     {

Rubberduck.CodeAnalysis/Inspections/Concrete/EmptyBlock/EmptyElseBlockInspection.cs

@@ -15,6 +15,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete.EmptyBlock
     /// an empty block may be signalling an unfinished thought or an oversight.
     /// </why>
     /// <example hasResult="true">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Boolean)
     ///     If foo Then
@@ -23,15 +24,18 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete.EmptyBlock
     ///     End If
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     /// <example hasResult="false">
+    /// <module name="MyModule" type="Standard Module">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal foo As Boolean)
     ///     If foo Then
     ///         ' ...
     ///     End If
     /// End Sub
     /// ]]>
+    /// </module>
     /// </example>
     internal sealed class EmptyElseBlockInspection : EmptyBlockInspectionBase<VBAParser.ElseBlockContext>
     {