MethodName check fails on constructor of nested class

[rasmusbonnedal]

Description

MethodName check misidentifies the constructor of a nested class as a method

Steps to reproduce the problem

Add this to cxx-checks/src/test/resources/checks/MethodName.cc and run mvn test

class OuterClass {
  class Inner_Class {
    Inner_Class();
  };
};

OuterClass::Inner_Class::Inner_Class()
{
}

Expected behavior

That Inner_Class constructor would not fail MethodName check.

Actual behavior

Inner_Class constructor fails MethodName check.

Known workarounds

Please provide a description of any known workarounds.

LOG file

Output from mvn test

[ERROR] Tests run: 1, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.018 s <<< FAILURE! - in org.sonar.cxx.checks.naming.MethodNameCheckTest
[ERROR] test(org.sonar.cxx.checks.naming.MethodNameCheckTest)  Time elapsed: 0.018 s  <<< FAILURE!
java.lang.AssertionError: 

No more violations expected
got: at line 51
        at org.sonar.cxx.checks.naming.MethodNameCheckTest.test(MethodNameCheckTest.java:50)

Related information

• cxx plugin version: latest master 2018-09-21 (g071070...). Same result in 1.1.0
• SonarQube version: 6.7.5

[ivangalkin]

Hello @rasmusbonnedal and thank you for reaching out.

Do you use some custom regexp to ensure the naming convention?

If not: there is probably no relation to the nesting. As you see...

public class MethodNameCheck extends SquidCheck<Grammar> {

  private static final String DEFAULT = "^[A-Z][A-Za-z0-9]{2,30}$";

... the underscore is considered to be an undesirable part of methods' names by default (see CamelCase). In case you would like to accept it, please navigate to the rule cxx.MethodName/c.MethodName and customize the format according to your naming convention (in case format is read-only, you should create a copy of default quality profile and use this copied profile in your project).

Regards,

[rasmusbonnedal]

Hi @ivangalkin, thanks for your quick response!

We do have a custom regexp but I still think this is a general issue and indeed related to nesting.

In MethodNameCheck.java there is code to detect if the method is a constructor and in that case not enforce the naming convention. This allows us to have class name convention != method name convention and not get issues on all constructors. This works well in outer classes but fails in inner classes. To illustrate this I changed my test case in MethodName.cc to this:

class Outer_Class {
  Outer_Class();
  class Inner_Class {
    Inner_Class();
  };
};

Outer_Class::Outer_Class() // This does not give an error
{
}

OuterClass::Inner_Class::Inner_Class() // This gives an error
{
}

I think this discrepancy between outer and inner class constructors in MethodName check is not expected.

[ivangalkin]

Hi @rasmusbonnedal,

I double-checked the code. MethodNameCheck.java applies the regexp only if the method is considered to be not a constructor and not a destructor (by the way I believe the destructor detection might be incomplete). So you're right.

Inner_Class::Inner_Class() is not recognized as a constructor implementation. Thereby the constructor declaration works well (at least in your example).

In any way I confirm the bug. We have to modify the constructor/destructor detection.

Thank you

[rasmusbonnedal]

@ivangalkin: Awesome, thanks!