Mastering MISRA C++ Compliance with CppDepend

Understanding CppDepend Support for MISRA C++ Compliance

Introduction

In today's rapidly evolving automotive industry, the importance of reliable and safe software cannot be overstated. The Motor Industry Software Reliability Association (MISRA) plays a crucial role in establishing best practices for developing safety-related electronic systems in road vehicles and other embedded systems. As a collaborative effort between vehicle manufacturers, component suppliers, and engineering consultancies, MISRA aims to ensure the highest standards in software reliability.

One essential tool for achieving MISRA C++ compliance is CppDepend, which helps developers adhere to these stringent guidelines. In this comprehensive guide, we will explore the pivotal role of MISRA in the automotive industry and how CppDepend can support developers in creating safer, more reliable software for vehicles and embedded systems.

To learn Misra C++ Standards, you can print the official Misra C++ 2008 Standard documentation.

Using Misra Rules in CppDepend

When you create a new CppDepend Project, a pop-up will appear displaying all the coding standards you would like to include in your analysis. To include MISRA C++ coding standards, check the MISRA option and choose MISRA C++.

After analyzing your project, Navigate to the Queries and Rules Explorer section, and select the Misra Rules from the left-hand menu (Highlighted in red in the image below). This will display all the related Misra rules on the right. Upon clicking a Rule, the corresponding CQLinq query and the relevant source code will be automatically generated. Additionally, the Metrics View section provides a visualization of the issue's location and significance.

Incorporating Misra Rules into the HTML Report

To include the Misra rules in the generated HTML Report (available in the DevOps Edition), simply right-click on the Misra group and select "List Code Queries of this Group in a dedicated section in Report."

List of Misra C++ Rules

CppDepend offers support for 103 Misra C++ standard queries.

To gain a deeper understanding of each rule and its functionality, please consult the official Misra C++ 2008 Standard documentation.

9 Uncessary Constructs,
1 Storage,
8 Lexical Conventions,
7 Basic Concepts,
4 Standard Conversions,
17 Expressions,
15 Statements,
8 Declarations,
6 Declarators,
7 Classes,
5 Exceptions,
4 Preprocessor,
12 Library.

Uncessary Constructs

Rule 0–1–1

This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unreachable" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 0–1–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="knownConditionTrueFalse" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 0–1–3

This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unused_variable" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 0–1–4
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="unreadVariable" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 0–1–5
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unused_local_typedef" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 0-1-7
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Misra" && issue.Type=="Rule0-1-7" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 0-1-9
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unreachable" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 0–1–11
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues
where issue.ToolName=="Clang" && issue.Type=="warn_unused_parameter"
&& issue.RelatedMethod!=null && issue.RelatedMethod.IsVirtual
select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 0-1-12
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues
where issue.ToolName=="Clang" && issue.Type=="warn_unused_parameter"
&& issue.RelatedMethod!=null && !issue.RelatedMethod.IsVirtual
select new { issue,issue.FilePath,Line=issue.BeginLine}

Storage

Rule 0–2–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang-Tidy" && issue.Type=="cppcoreguidelines-pro-type-union-access" select
new { issue,issue.FilePath,Line=issue.BeginLine}

Lexical Conventions

Rule 2–3–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="trigraph_ignored" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 2-5-1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_cxx98_compat_less_colon_colon" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 2–7–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_nested_block_comment" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 2–10–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_decl_shadow" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 2-10-6
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="err_redefinition_different_kind" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 2–13–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="ext_unknown_escape" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 2–13–3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule2-13-3" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 2–13–4
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule2-13-4" select
new { issue,issue.FilePath,Line=issue.BeginLine}

Basic Concepts

Rule 3–1–1
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.NbLinesOfCode>0
&& m.SourceDecls.First().SourceFile.FileNameExtension.StartsWith("h")
select new { m,IncludeFile=m.SourceDecls.First().SourceFile.FilePathString }
Rule 3–1–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule3-1-2"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 3–1–3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule3-1-3"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 3–3–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule3-3-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 3–3–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule3-3-2"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 3–4–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="variableScope"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 3–9–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule3-9-2"
select new { issue,issue.FilePath,Line=issue.BeginLine}

Standard Conversions

Rule 4–5–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule4-5-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 4–5–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule4-5-2"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 4–5–3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule4-5-3"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 4–10–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule4-10-2"
select new { issue,issue.FilePath,Line=issue.BeginLine}

Expressions

Rule 5–0–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unsequence_mod_use" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–0–4
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_impcast_integer_sign" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–0–5
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_impcast_float_integer" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–0–6
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_impcast_integer_precision" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5-0-7
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang-Tidy" && issue.Type=="bugprone-integer-division" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–0–9
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_impcast_integer_sign" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–0–15
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang-Tidy" && issue.Type=="cppcoreguidelines-pro-bounds-pointer-arithmetic" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–0–18
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="comparePointers" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–2–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="err_static_downcast_via_virtual" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–2–4
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_old_style_cast" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–2–6
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_cxx98_compat_cast_fn_obj" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–3–3
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.SimpleName== "operator&"
select m
Rule 5–3–4
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_side_effects_unevaluated_context_sizeof" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–8–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule5-8-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–14–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule5-14-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5–18–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule5-18-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 5-2-11
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.SimpleName== "operator&"
select m

Statements

Rule 6–2–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-2-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–2–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_floatingpoint_eq" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–2–3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-2-3"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–3–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-3-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–4–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-4-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–4–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-4-2"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6-4-3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="warn_jump_out_of_scope" || issue.Type=="Rule6-6-2" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–4–4
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-4-4"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–4–5
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unannotated_fallthrough" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–4–6
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-4-6"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–4–7
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_bool_switch_condition" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–4–8
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-4-8"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–6–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_jump_out_of_scope" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–6–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-6-2" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 6–6–5
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule6-6-5" select
new { issue,issue.FilePath,Line=issue.BeginLine}

Declarations

Rule 7-2-1
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.SimpleName=="main" && m.ParentNamespace.Name!=""
select m
Rule 7-3-1
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.SimpleName=="main" && m.ParentNamespace.Name!=""
select m
Rule 7–3–2
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.SimpleName=="main" && m.ParentNamespace.Name!=""
select m
Rule 7–3–3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule7-3-3"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 7–3–4
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule7-3-4"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 7–4–2
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.SimpleName=="main" && m.ParentNamespace.Name!=""
select m
Rule 7–5–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="returnAddressOfAutoVariable" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 7–5–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="deadpointer" select
new { issue,issue.FilePath,Line=issue.BeginLine}

Declarators

Rule 8–4–1
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.IsVariadic
select m
Rule 8–4–3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_maybe_falloff_nonvoid_function" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 8–4–4
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_duplicate_enum_values" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 8–5–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_uninit_var" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 8–5–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_missing_braces" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 8–5–3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_duplicate_enum_values" select
new { issue,issue.FilePath,Line=issue.BeginLine}

Classes

Rule 9–5–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule9-5-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 10–1–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule10-1-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 10–3–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule10-3-2"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 11–0–1
This coding standard is computed with the following query:

warnif count > 0
from f in JustMyCode.Fields where !f.ParentType.IsPOD && f.IsPublic
select f
Rule 12–1–1
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where
(m.IsConstructor || m.IsDestructor)
&& (m.MethodsCalled.Where(vm=>vm.IsVirtual).Count()>0 || m.IsUsing("Keywords.dynamic_cast".AllowNoMatch()))
select m
Rule 12–1–2
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.IsConstructor && m.Params.Count()==1 && m.Params.First().ParamType!=null
&& m.Params.First().ParamType.Name=="int" && !m.IsExplicitConstructor
select m
Rule 12–8–2
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.SimpleName== "operator=="
&& m.ParentType.IsAbstract && m.IsPublic
select m

Exceptions

Rule 15–0–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule15-0-2"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 15–3–2
This coding standard is computed with the following query:

warnif count > 0
from m in JustMyCode.Methods where m.IsEntryPoint
&& m.IsUsing("Keywords.generic_catch".AllowNoMatch()) select m
Rule 15–3–5
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="catchExceptionByValue"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 15–3–7
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_exception_caught_by_earlier_handler" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 15–5–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="exceptThrowInDestructor"
select new { issue,issue.FilePath,Line=issue.BeginLine}

Preprocessor

Rule 16–0–3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_undef_used" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 16–0–7
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_pp_undef_identifier" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 16–3–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_pp_hashhash_used" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 16–3–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_pp_hash_used" select
new { issue,issue.FilePath,Line=issue.BeginLine}

Library

Rule 17–0–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_reserved_id_macro" select
new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 17–0–5
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule17-0-5"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 18–0–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule18-0-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 18–0–2
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule18-0-2"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 18–0–3
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule18-0-3"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 18–0–4
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule18-0-4"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 18–0–5
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule18-0-5"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 18–2–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule18-2-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 18–4–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule18-4-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 18–7–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule18-7-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 19–3–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule19-3-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}
Rule 27–0–1
This coding standard is computed with the following query:

warnif count > 0
from issue in ImportedIssues where issue.Type=="Rule18-4-1"
select new { issue,issue.FilePath,Line=issue.BeginLine}

Go to top