[clang-tidy] aliases for safety module from section 8 to 12 done

[JonasToth]

Summary

This commit will add aliases into the safety module from other modules.
Since the original purpose of the effort was to implement the High Integrity Coding Standard,
Jonathan (jbcoe) and me had the idea to start out by figuring out what is already done
in clang-tidy.
Splitting the whole standard into parts, this work checked the section 8 to 12.

I made a todolist for me, which can be seen here: https://github.com/JonasToth/HighIntegrityTooling

When we are done aliasing, we create real todos and would like to migrate the list to issues
in the llvm issue tracker.

Please give your opinion on that approach.

[JonasToth]

[Fix] typos in the module file - actually builds now :D

[alexfh]

docs/ReleaseNotes.rst

75–79

Should we have a separate module for the High Integrity C++ Coding Standard as we have for CERT? It seems natural to be able to check the code for HIC++ conformance instead of checking it for conformance with some "safety" checks. Isn't it?

docs/clang-tidy/checks/safety-explicit-conversions.rst

5 ↗

(On Diff #89813)

How about adding links to the specific HIC++ rule this check enforces? Same for other checks.

[JonasToth]

docs/ReleaseNotes.rst

75–79

Yes, AFAIK was the safety module the starting point of that standard. But the naming is not explicit about it. Maybe we could discuss about a rebranding of the safety module. @jbcoe what do you think?

Furthermore, is it possible to configure aliased checks specially? It makes sense to set the default values/configuration so that it truly confirms.
Most aliases are just "we can do it with this one". Overview pages for different standards would be interesting as well, but out of scope for now, i would say.

docs/clang-tidy/checks/safety-explicit-conversions.rst

5 ↗

(On Diff #89813)

Yup. I will update when the naming issue from above is clearer.

[aaron.ballman]

docs/ReleaseNotes.rst

75–79

I think it's a good idea -- but, as with CERT, we should make sure we have the permission to use that specific name in our documentation and naming of the module. See LICENSE.TXT and clang-tidy/cert/LICENSE.TXT.

[jbcoe]

docs/ReleaseNotes.rst

75–79

I contacted Programming Research, the authors of HIC++ and have not received a reply.

I would like to name this clang-tidy module after HIC++ but am not happy to do so without permission as it suggests endorsement.

As Aaron suggests, without permission we are probably better off rescinding references to HIC++ entirely and leaving a generic (and still very useful) safety module in place.

[aaron.ballman]

docs/ReleaseNotes.rst

75–79

That wasn't what I was suggesting -- I think having the module would be natural and consistent. The way I read the Conditions of Use is that it cannot imply *PRQA* endorses this use, which I don't think we're in danger of here.

I think we're fine so long as we properly attribute in the license (because we may be using names from the coding standard). Of course, IANAL, etc. ;-)

[JonasToth]

docs/ReleaseNotes.rst

75–79

Programming Research LTD business is to make static code analysis tools.
so i think, we cut their business interest implementing their HIC++ -standard.

probably better to be on the safe site and say the safety module is inspired by HIC++ and others. CERT and MISRA have stuff to say about c++ as well right?
i think we should be sure that we are allowed to use their name and implement their standard, because if we are not, it makes sense for them to sue. at least my thoughts.

maybe we can implement in the old categories + safety and provide example configuration files that would enforce one standard.

@jbcoe did you ask a clang/llvm or urself? Maybe their could be an official request to the company, they probably react to that one.

[aaron.ballman]

docs/ReleaseNotes.rst

75–79

Programming Research LTD business is to make static code analysis tools. so i think, we cut their business interest implementing their HIC++ -standard.
probably better to be on the safe site and say the safety module is inspired by HIC++ and others. CERT and MISRA have stuff to say about c++ as well right?

Correct, hence why we've updated the license for CERT. As for HIC++ , their Conditions of Use are pretty easy to read and interpret. Personally, I don't think we have much to worry about in this regard, so long as we perform the proper attribution they ask for.

i think we should be sure that we are allowed to use their name and implement their standard, because if we are not, it makes sense for them to sue. at least my thoughts.

We have that permission from CERT. We have no such permission from MISRA.

[JonasToth]

docs/ReleaseNotes.rst

75–79

i dont mind these issues tbh :D
just dont want to be the root of later problems :)

iam fine with it, if you are as well.

[jbcoe]

docs/ReleaseNotes.rst

75–79

I asked as myself.

Maybe a senior clang-community member with some CERT background (Aaron?) could ask on behalf of LLVM/Clang.

[aaron.ballman]

docs/ReleaseNotes.rst

75–79

It just so happens there is a PRQA person here at the WG21 meetings. I spoke with him and he said that he will poke the appropriate people to ensure you get a response in a timely manner.

[jbcoe]

docs/ReleaseNotes.rst

75–79

Can we merge this subject to probable revision when PRQA get back to us?
I'm happy to make the code changes needed to rename things when required.

[alexfh]

docs/ReleaseNotes.rst

75–79

If it doesn't take more than a couple of weeks, I'd better wait until we have an answer from PRQA or otherwise reach clarity on how we can refer to the HIC++ standard.

This patch is not going to bitrot soon, and I'd like to avoid unnecessary churn, if possible.

[aaron.ballman]

docs/ReleaseNotes.rst

75–79

I agree. PRQA will hopefully respond soon, or @dberlin will weigh in. Either way, I think the module can wait for a short while to avoid churn.

[jbcoe]

@aaron.ballman any news for PRQA on naming this module? Seems a shame to block good work.

[aaron.ballman]

In D30383#700307, @jbcoe wrote:

@aaron.ballman any news for PRQA on naming this module? Seems a shame to block good work.

I was hoping you had heard from them. Have you received any communications from PRQA (and if so, from who)? I'll see if the person I know from PRQA can get the ball rolling again.

In the meantime, @dberlin, can you comment on whether you think we should be fine to use the name "High Integrity C++ Coding Standard" in our documentation and as a clang-tidy module name (provided we update our license similar to how we did for the CERT module)?

[aaron.ballman]

docs/ReleaseNotes.rst

75–79

I've heard back from PRQA, and they are happy for us to proceed.

"We are perfectly happy for Clang community or any individuals to add in-built or plug-in support for parts of HICPP. We do want an attribution alongside any rule enforcement or rule reference."

I've clarified the attribution with them, and we should proceed in the same way we did with the CERT rules. Basically, we add a LICENSE.TXT to include what's in the Conditions of Use, link to it from the clang-tools-extra LICENSE.TXT, and the documentation for the HIC++ checks should link back to the HIC++ coding standard directly.

I recommend we put this in a module named "hicpp" or "hic++" rather than "safety" to make it clear that the modules relate to the coding standard directly.

[JonasToth]

docs/ReleaseNotes.rst

75–79

That sounds really nice :)
I will proceed with adding the reference to the checks.
I don't know about the License Docs, could someone else do this, or at least point me in the right direction?

Renaming the whole module is ok with me.

[aaron.ballman]

docs/ReleaseNotes.rst

75–79

I think this should be done in two steps (in separate patches). I'll go ahead and take care of the initial patch, and once that's in, you can rebase this patch on top of it. The new patch will:

• Rename the safety directory to hicpp
• Rename the SafetyTidyModule.cpp file to HICPPTidyModule.cpp
• Rename the safety checks to hicpp checks
• Update extra/LICENSE.TXT
• Add extra/clang-tidy/hicpp/LICENSE.TXT

Hopefully this doesn't cause merge issues for you.

[aaron.ballman]

docs/ReleaseNotes.rst

75–79

I've commit this change in r298229, so you should be safe to rebase now.

[JonasToth]

Update the aliases to reflect the new name and link to the related rules in High Integrity C++

• [Merge] Transition to hicpp wording
• [Rename] rename safety files
• Substitute safety with hicpp
• [Doc] references to the section in hicpp added

[JonasToth]

• [Doc] add rule to every mention of the rule number

[jbcoe]

I wonder if it's worth adding a module-level test so that people could easily see that various violations of HICPP are diagnosed?

clang-tools-extra/tests/clang-tidy/test-hicpp.cpp

I'm a bit nervous about code going in without tests and more nervous about the aliases being ok now but wrong later if one of the aliased checks changes its meaning.

[JonasToth]

@jbcoe Yeah that is actually a good point. Can the aliases be configured independent with default arguments? That would be a good improvement as well. For example function-size could take different default parameters.

But i think not every check needs to be tested. Lets say hicpp-use-equals-delete is really simplistic? and the test on the check itself should be sufficient.
Maybe an example configuration file would be nice as well.

[jbcoe]

docs/clang-tidy/checks/hicpp-identifier-naming.rst

8

I'm not sure this is the right check.

I think you want readability-named-parameter.
https://clang.llvm.org/extra/clang-tidy/checks/readability-named-parameter.html

readability-identifier-naming takes masses of config and uses it to enforce naming conventions like snake case and trailing _ for member variables.
https://clang.llvm.org/extra/clang-tidy/checks/readability-identifier-naming.html

docs/clang-tidy/checks/hicpp-undelegated-constructor.rst

9

typo codeduplication

[JonasToth]

• [Fix] wrong alias mentioned by jonathan

[JonasToth]

docs/clang-tidy/checks/hicpp-identifier-naming.rst

8

jup. adjusted.

docs/clang-tidy/checks/hicpp-undelegated-constructor.rst

9

what would be the correct spelling? xD
code duplication?

[JonasToth]

• [Fix] typo for code duplication

[aaron.ballman]

clang-tidy/hicpp/HICPPTidyModule.cpp

35–62

This should be removed -- it's handled below.

docs/ReleaseNotes.rst

81–82

This should link to the HIC++ standard online.

84

I think we can go ahead and remove this, because *everything* in the hicpp module will be new for this release.

docs/clang-tidy/checks/hicpp-explicit-conversions.rst

8

If it doesn't enforce some part of a rule, I think we should call that out explicitly and probably provide wording and an example of what does and does not comply with the rule. Users are going to want to know what level of enforcement there is for a safety-related standard.

Same comments apply to all the docs that claim partial enforcement.

docs/clang-tidy/checks/hicpp-function-size.rst

8

Typo: useful

docs/clang-tidy/checks/hicpp-named-parameter.rst

8 ↗

(On Diff #92294)

Drop "the"

docs/clang-tidy/checks/hicpp-new-delete-operators.rst

9

Implements <blah> to ensure the new and delete operators have the correct signature.

docs/clang-tidy/checks/hicpp-special-member-functions.rst

8

function -> functions

docs/clang-tidy/checks/hicpp-undelegated-constructor.rst

9

This last sentence is ungrammatical, but will likely be improved when you add the extra information about what the check does and does not get right versus the rule.

Also, we probably shouldn't say the check "tries" to implement something. It implements partial support. ;-)

docs/clang-tidy/checks/hicpp-use-equals-default.rst

8

Implement -> Implements
to default -> to explicitly default

docs/clang-tidy/checks/hicpp-use-equals-delete.rst

9

to explicitly default or delete.

docs/clang-tidy/checks/hicpp-use-override.rst

9

to declare a virtual function

[JonasToth]

• [Doc] fix the bad grammar and typos

[JonasToth]

fixed the easier issues.

[JonasToth]

• [Doc] grammar and content fixed

[JonasToth]

nontypo fixes.

[JonasToth]

• minor fix, commas not needed in enumeration

[aaron.ballman]

docs/clang-tidy/checks/hicpp-explicit-conversions.rst

10

castingchecks -> casting checks

docs/clang-tidy/checks/hicpp-named-parameter.rst

4 ↗

(On Diff #93038)

This underline is too long.

docs/clang-tidy/checks/hicpp-undelegated-constructor.rst

11

Rather than saying it's not easily done automatically, it would be more useful to the user to provide examples of what does and does not match the specific coding rule.

[JonasToth]

docs/clang-tidy/checks/hicpp-undelegated-constructor.rst

11

I used the examples from the testcase, i hope its ok this way.

[JonasToth]

• [Docs] Typos fixed
• [Doc] improve documentation on what is done in the delegation constructor check

[aaron.ballman]

LGTM!

[jbcoe]

@JonasToth If you don't have commit access let me know and I can merge this patch for you.

[JonasToth]

@jbcoe I dont have them, Thank you for commiting :)

[malcolm.parsons]

The docs for all these aliases are missing http redirects e.g.

.. meta::
   :http-equiv=refresh: 5;URL=modernize-use-equals-delete.html

Without these redirects, the automatically generated list of checks (list.rst) does not say that the checks redirect.

clang-tidy/hicpp/HICPPTidyModule.cpp

 //===------- HICPPTidyModule.cpp - clang-tidy -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
+#include "../cppcoreguidelines/ProTypeMemberInitCheck.h"
+#include "../cppcoreguidelines/SpecialMemberFunctionsCheck.h"
+#include "../google/DefaultArgumentsCheck.h"
+#include "../google/ExplicitConstructorCheck.h"
+#include "../misc/NewDeleteOverloadsCheck.h"
+#include "../misc/NoexceptMoveConstructorCheck.h"
+#include "../misc/UndelegatedConstructor.h"
+#include "../misc/UseAfterMoveCheck.h"
+#include "../modernize/UseEqualsDefaultCheck.h"
+#include "../modernize/UseEqualsDeleteCheck.h"
+#include "../modernize/UseOverrideCheck.h"
+#include "../readability/FunctionSizeCheck.h"
+#include "../readability/IdentifierNamingCheck.h"
 #include "NoAssemblerCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace hicpp {
 
 class HICPPModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<NoAssemblerCheck>(
         "hicpp-no-assembler");
+    CheckFactories.registerCheck<google::ExplicitConstructorCheck>(
+        "hicpp-explicit-conversions");
+    CheckFactories.registerCheck<readability::FunctionSizeCheck>(
+        "hicpp-function-size");
+    CheckFactories.registerCheck<readability::IdentifierNamingCheck>(
+        "hicpp-identifier-naming");
+    CheckFactories.registerCheck<misc::UseAfterMoveCheck>(
+        "hicpp-invalid-access-moved");
+    CheckFactories.registerCheck<cppcoreguidelines::ProTypeMemberInitCheck>(
+        "hicpp-member-init");
+    CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
+        "hicpp-new-delete-operators");
+    CheckFactories.registerCheck<misc::NoexceptMoveConstructorCheck>(
+        "hicpp-noexcept-move");
+    CheckFactories.registerCheck<NoAssemblerCheck>("hicpp-no-assembler");
+    CheckFactories
+        .registerCheck<cppcoreguidelines::SpecialMemberFunctionsCheck>(
+            "hicpp-special-member-functions");
+    CheckFactories.registerCheck<misc::UndelegatedConstructorCheck>(
+        "hicpp-undelegated-constructor");
+    CheckFactories.registerCheck<modernize::UseEqualsDefaultCheck>(
+        "hicpp-use-equals-default");
+    CheckFactories.registerCheck<modernize::UseEqualsDeleteCheck>(
+        "hicpp-use-equals-delete");
+    CheckFactories.registerCheck<modernize::UseOverrideCheck>(
+        "hicpp-use-override");
   }
 };
 
 // Register the HICPPModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<HICPPModule>
     X("hicpp-module", "Adds High-Integrity C++ checks.");
 
 } // namespace hicpp
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the HICPPModule.
 volatile int HICPPModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

docs/ReleaseNotes.rst

- Improved `cppcoreguidelines-no-malloc
 
   Allow custom memory management functions to be considered as well.
 
 - New `readability-misleading-indentation
   <http://clang.llvm.org/extra/clang-tidy/checks/readability-misleading-indentation.html>`_ check
 
   Finds misleading indentation where braces should be introduced or the code should be reformatted.
 
 - Added `ParameterThreshold` to `readability-function-size`.
 
   Finds functions that have more then `ParameterThreshold` parameters and emits a warning.
 
-- New `safety-no-assembler
+- New `hicpp` module
+
+  Adds checks that implement the High Integrity C++ Coding Standard and other safety
+  standards. Many checks are aliased to other modules.
+
+- New `hicpp-no-assembler
   <http://clang.llvm.org/extra/clang-tidy/checks/safety-no-assembler.html>`_ check
 
   Finds uses of inline assembler.
 
 - New `modernize-return-braced-init-list
   <http://clang.llvm.org/extra/clang-tidy/checks/modernize-return-braced-init-list.html>`_ check
 
   Finds and replaces explicit calls to the constructor in a return statement by

docs/clang-tidy/checks/hicpp-explicit-conversions.rst

+.. title:: clang-tidy - hicpp-explicit-conversions
+
+hicpp-explicit-conversions
+==========================
+
+This check is an alias for `google-explicit-constructor <google-explicit-constructor.hml>`_.
+Used to enforce parts of `Section 5.4.1 <http://www.codingstandard.com/rule/5-4-1-only-use-casting-forms-static_cast-excl-void-dynamic_cast-or-explicit-constructor-call/>`_.

docs/clang-tidy/checks/hicpp-function-size.rst

+.. title:: clang-tidy - hicpp-function-size
+
+hicpp-function-size
+===================
+
+This check is an alias for `readability-function-size <readability-function-size.hml>`_.
+Usefull to enforce multiple sections on function complexity.
+
+- `section 8.2.2 <http://www.codingstandard.com/rule/8-2-2-do-not-declare-functions-with-an-excessive-number-of-parameters/>`_
+- `section 8.3.1 <http://www.codingstandard.com/rule/8-3-1-do-not-write-functions-with-an-excessive-mccabe-cyclomatic-complexity/>`_
+- `section 8.3.2 <http://www.codingstandard.com/rule/8-3-2-do-not-write-functions-with-a-high-static-program-path-count/>`_

docs/clang-tidy/checks/hicpp-identifier-naming.rst

+.. title:: clang-tidy - hicpp-identifier-naming
+
+hicpp-identifier-naming
+=======================
+
+This check is an alias for `readability-identifier-naming <readability-identifier-naming.hml>`_.
+
+Implements the rule `8.2.1 <http://www.codingstandard.com/rule/8-2-1-make-parameter-names-absent-or-identical-in-all-declarations/>`_.

docs/clang-tidy/checks/hicpp-invalid-access-moved.rst

+.. title:: clang-tidy - hicpp-invalid-access-moved
+
+hicpp-invalid-access-moved
+==========================
+
+This check is an alias for `misc-use-after-move <misc-use-after-move.hml>`_.
+
+Implements parts of the rule `8.4.1 <http://www.codingstandard.com/rule/8-4-1-do-not-access-an-invalid-object-or-an-object-with-indeterminate-value/>`_ to check if moved-from objects are accessed.

docs/clang-tidy/checks/hicpp-member-init.rst

+.. title:: clang-tidy - hicpp-member-init
+
+hicpp-member-init
+=================
+
+This check is an alias for `cppcoreguidelines-pro-type-member-init <cppcoreguidelines-pro-type-member-init.hml>`_.
+Implements the check for 
+`12.4.2 <http://www.codingstandard.com/rule/12-4-2-ensure-that-a-constructor-initializes-explicitly-all-base-classes-and-non-static-data-members/>`_ 
+to initialize class members in the right order.

docs/clang-tidy/checks/hicpp-new-delete-operators.rst

+.. title:: clang-tidy - hicpp-new-delete-operators
+
+hicpp-new-delete-operators
+==========================
+
+This check is an alias for `misc-new-delete-overloads <misc-new-delete-overloads.hml>`_.
+Implements `12.3.1 <http://www.codingstandard.com/section/12-3-free-store/>`_ to overload 
+`new` and `delete` operators correct.

docs/clang-tidy/checks/hicpp-noexcept-move.rst

+.. title:: clang-tidy - hicpp-noexcept-move
+
+hicpp-noexcept-move
+===================
+
+This check is an alias for `misc-noexcept-moveconstructor <misc-noexcept-moveconstructor.hml>`_.
+Checks `12.5.4 <http://www.codingstandard.com/rule/12-5-4-declare-noexcept-the-move-constructor-and-move-assignment-operator/`_ to mark move assignment and move construction `noexcept`.

docs/clang-tidy/checks/hicpp-special-member-functions.rst

+.. title:: clang-tidy - hicpp-special-member-functions
+
+hicpp-special-member-functions
+==============================
+
+This check is an alias for `cppcoreguidelines-special-member-functions <cppcoreguidelines-special-member-functions.hml>`_.
+Checks that special member function have the correct signature, according to `12.5.7 <http://www.codingstandard.com/rule/12-5-7-declare-assignment-operators-with-the-ref-qualifier/>`_.

docs/clang-tidy/checks/hicpp-undelegated-constructor.rst

+.. title:: clang-tidy - hicpp-undelegated-construtor
+
+hicpp-undelegated-constructor
+=============================
+
+This check is an alias for `misc-undelegated-constructor <misc-undelegated-constructor.hml>`_.
+Tries to implement `12.4.5 <http://www.codingstandard.com/rule/12-4-5-use-delegating-constructors-to-reduce-code-duplication/>`_ based on suspicous function calls.
+That will not find every codeduplication and possibility to use delegating constructors.

docs/clang-tidy/checks/hicpp-use-equals-default.rst

+.. title:: clang-tidy - hicpp-use-equals-defaults
+
+hicpp-use-equals-default
+========================
+
+This check is an alias for `modernize-use-equals-default <modernize-use-equals-default.hml>`_.
+Implement `12.5.1 <http://www.codingstandard.com/rule/12-5-1-define-explicitly-default-or-delete-implicit-special-member-functions-of-concrete-classes/>`_ to default special member functions.

docs/clang-tidy/checks/hicpp-use-equals-delete.rst

+.. title:: clang-tidy - hicpp-use-equals-delete
+
+hicpp-use-equals-delete
+=======================
+
+This check is an alias for `modernize-use-equals-delete <modernize-use-equals-delete.hml>`_.
+Implements `12.5.1 <http://www.codingstandard.com/rule/12-5-1-define-explicitly-default-or-delete-implicit-special-member-functions-of-concrete-classes/>`_ 
+to default and delete special member functions.

docs/clang-tidy/checks/hicpp-use-override.rst

+.. title:: clang-tidy - hicpp-use-override
+
+hicpp-use-override
+==================
+
+This check is an alias for `modernize-use-override <modernize-use-override.hml>`_.
+Implements `10.2.1 <http://www.codingstandard.com/section/10-2-virtual-functions/>`_ to 
+declare virtual function `override` when overriding.