[clang-tidy] Adding Fuchsia checkers to clang-tidy

[juliehockett]

Summary

Adds a new Fuchsia module to clang-tidy to warn for features that are
disallowed in the Fuchsia and Zircon style guides.

Fuchsia is a modular, capability-based operating system. Fuchsia and its
Zircon kernel use a subset of the C++14 language, and so these checks
are designed to prompt the user to avoid disallowed behaviors.

Adds a check to the Fuchsia modules to warn when functions are declared
or called with default arguments.

See https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md for
reference.

[Eugene.Zelenko]

Please split this review with one check per review.

docs/ReleaseNotes.rst

83

Please fix double space

docs/clang-tidy/checks/fuchsia-default-arguments.rst

9

Please don't use abbreviations. Same in other places.

20

Please insert empty line above.

docs/clang-tidy/checks/fuchsia-statically-constructed-objects.rst

7 ↗

(On Diff #123103)

Please highlight constexpr with ``. Same in other places.

docs/clang-tidy/checks/fuchsia-thread-local.rst

6 ↗

(On Diff #123103)

Please highlight thread-local and extern with ``. Same in other places.

[Eugene.Zelenko]

clang-tidy/fuchsia/FuchsiaTidyModule.cpp

32

Please remove empty line.

clang-tidy/fuchsia/MultipleInheritanceCheck.cpp

100 ↗

(On Diff #123103)

Please remove empty line.

docs/ReleaseNotes.rst

63

Check to should be removed, just Prevent. Same in other places.

[Eugene.Zelenko]

Please mention new module in docs/clang-tidy/index.rst.

[aaron.ballman]

For background: what is Fuchsia and where do these requirements come from (are they documented publicly somewhere)?

We tend to prefer concise patches over code dumps, so I think it would make sense to split this review into multiple patches. The first one can be adding the module and a single check along with background information on why the module would be appropriate. The rest of the patches should be one check per patch.

[Eugene.Zelenko]

docs/ReleaseNotes.rst

60

Check name and link was accidentally removed.

docs/clang-tidy/checks/list.rst

59

List should be pruned.

[juliehockett]

Updated docs

[juliehockett]

We do need to figure out what the right prefix for these checks is (whether fuchsia-* since they'll be used under the Fuchsia umbrella, zircon-* since the follow the Zircon section of the style guide linked above, or the more generic google-*).

[Eugene.Zelenko]

Does Fuchsia coding conventions allows default parameters in class methods? If not, test should reflect this

docs/ReleaseNotes.rst

63

I think will be good idea to have description same as first sentence in documentation, i. e. Warns if a function is declared or called with default arguments.

test/clang-tidy/fuchsia-default-arguments.cpp

7

Please remove void (see modernize-redundant-void-arg). Same below.

[Eugene.Zelenko]

In D40108#928212, @juliehockett wrote:

We do need to figure out what the right prefix for these checks is (whether fuchsia-* since they'll be used under the Fuchsia umbrella, zircon-* since the follow the Zircon section of the style guide linked above, or the more generic google-*).

I think it should use project-specific prefix, since it's open source project. Google may have different coding guidelines for other projects.

[juliehockett]

Updated docs and added tests to check class methods.

[juliehockett]

In D40108#928224, @Eugene.Zelenko wrote:

I think it should use project-specific prefix, since it's open source project. Google may have different coding guidelines for other projects.

Reasonable. It makes sense to consider it on a check-by-check basis too, I'd think.

[Eugene.Zelenko]

docs/ReleaseNotes.rst

63

I think will be good idea to change to function to function or method. Same in documentation.

docs/clang-tidy/checks/fuchsia-default-arguments.rst

9

I briefly look on other checks documentation, so will be good idea to use just Example: or For example, the declaration: . But will be good idea to hear opinion of native English speaker.

[aaron.ballman]

Thank you for the explanation about what is driving this and the documentation. I don't think google-* is the correct module for this as it's too general of an umbrella. I have a slight preference for zircon-* because this appears to be specific to that particular project.

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

19

I think this should be put into ASTMatchers.h as a separate patch (feel free to list me as a reviewer). See D39940 for an example of how to do that, but the only non-obvious task is running clang\docs\tools\dump_ast_matchers.py to generate the HTML from ASTMatchers.h.

23

Isn't this case already covered by the other matcher? Or do you have system header files which have default arguments and those functions are disallowed by the style guide, but cannot be removed from the system header?

29

You can use const auto * here instead of spelling the type out twice.

37

Would it make sense to add a fix-it that removes the intializer for the default argument?

docs/clang-tidy/checks/fuchsia-default-arguments.rst

9

I'd go with: For example, the declaration:

docs/clang-tidy/index.rst

672

Spurious newline removal?

[juliehockett]

Moved AST matcher out to ASTMatchers.h (see D40261), fixing comments

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

23

The latter -- there's a bunch of third-party code and the like that could have default arguments, but shouldn't be used like that in the project.

[aaron.ballman]

Did you decide on fuchsia instead of zircon for the module name, or is that decision still up in the air?

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

23

Ah, that makes sense. Thanks!

30

I think the diagnostic should be in singular form. How about: calling a function that uses a default argument is disallowed?

36–39

Does getDefaultArgRange() not provide the correct range already (so you don't need to go back to the original source)? Or does that range miss the =?

You might want to disable the fix-it in the case getDefaultArgRange() returns an empty range, or in case the default arg expression comes from a macro (and add a test for the latter case). e.g.,

#define DERP(val)  = val

void f(int i DERP);

Additionally, a test where the identifier is elided would be good as well: void f(int = 12);

42

This diagnostic could be similarly tightened -- the function isn't the issue, the parameter with the default argument is. Perhaps: declaring a parameter with a default value is disallowed?

docs/clang-tidy/checks/fuchsia-default-arguments.rst

17–18

The wording here is a bit confusing; it's not that calling it with no arguments causes the warning, it's that calling it such that the default argument value is used that's the problem. Perhaps: A function call expression that uses a default argument will be diagnosed. or something along those lines.

[juliehockett]

Disabled the fix-it for getDefaultArgRange() that returns an empty range and for default args that come from a macro.

[juliehockett]

We're going to go with fuchsia-* for the module name, since the style applies to the broader project. Also, there may be zircon-specific checks at some point, so we want to leave the door open for that.

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

36–39

getDefaultArgRange() misses the = -- though if there's a better way to do it I'm all ears!

[aaron.ballman]

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

32

Drop "the" from the diagnostic to match wording in other places

36–39

In that case, this seems fine to me.

45

Drop "the" here as well.

49–53

This can be hoisted to the initialization: SourceLocation StartLocation = D->getName().empty() ? D->getLocStart() : D->getLocation();

test/clang-tidy/fuchsia-default-arguments.cpp

41

I think this diagnostic should be suppressed -- having it on the declaration where the default argument is defined should be sufficient, no?

58

Two more test cases that should be added:

void f(int i);
void f(int i = 12);

void f(int i) {
    
}

struct S {
  void f(int i);
};

void S::f(int i = 12) {}

int main() {
  S s;
  s.f();
  f();
}

[juliehockett]

Added new tests and updated wording in warning.

[Eugene.Zelenko]

docs/clang-tidy/checks/fuchsia-default-arguments.rst

7

Please synchronize with text in Release Notes.

[juliehockett]

Updating docs

[aaron.ballman]

LGTM aside from one small nit with the test file missing a trailing newline.

test/clang-tidy/fuchsia-default-arguments.cpp

82

Please add a newline at the end of the file.

[juliehockett]

Added missing newline

[aaron.ballman]

Thanks for the nit fix. If you'd like me to commit this on your behalf, just let me know.

[juliehockett]

If you could, that'd be great! Thank you!

[aaron.ballman]

I've commit in r319225.

[Eugene.Zelenko]

In D40108#938131, @juliehockett wrote:

If you could, that'd be great! Thank you!

It'll be good idea it you'll request commit rights, since you have more checks in development queue.

[alexfh]

A couple of late comments.

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

40

No else after return, please. http://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

57

This argument is not used in the message. Does it have any effect at all?

docs/clang-tidy/index.rst

64

How about adding a link to the coding style document? (We should do this for other entries here, but that's unrelated to your patch.)

clang-tidy/CMakeLists.txt

add_clang_library(clangTidy
   clangToolingCore
   )
 
 add_subdirectory(android)
 add_subdirectory(boost)
 add_subdirectory(bugprone)
 add_subdirectory(cert)
 add_subdirectory(cppcoreguidelines)
+add_subdirectory(fuchsia)
 add_subdirectory(google)
 add_subdirectory(hicpp)
 add_subdirectory(llvm)
 add_subdirectory(misc)
 add_subdirectory(modernize)
 add_subdirectory(mpi)
 add_subdirectory(objc)
 add_subdirectory(performance)
 add_subdirectory(plugin)
 add_subdirectory(readability)
 add_subdirectory(tool)
 add_subdirectory(utils)

clang-tidy/fuchsia/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS support)
+
+add_clang_library(clangTidyFuchsiaModule
+  DefaultArgumentsCheck.cpp
+  FuchsiaTidyModule.cpp
+
+  LINK_LIBS
+  clangAST
+  clangASTMatchers
+  clangBasic
+  clangLex
+  clangTidy
+  clangTidyUtils
+  )

clang-tidy/fuchsia/DefaultArgumentsCheck.h

+//===--- DefaultArgumentsCheck.h - clang-tidy--------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// Default arguments are not allowed in declared or called functions.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-default-arguments.html
+class DefaultArgumentsCheck : public ClangTidyCheck {
+public:
+  DefaultArgumentsCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_H

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

+//===--- DefaultArgumentsCheck.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 "DefaultArgumentsCheck.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+void DefaultArgumentsCheck::registerMatchers(MatchFinder *Finder) {
+  // Calling a function which uses default arguments is disallowed.
+  Finder->addMatcher(cxxDefaultArgExpr().bind("stmt"), this);
+  // Declaring default parameters is disallowed.
+  Finder->addMatcher(parmVarDecl(hasDefaultArgument()).bind("decl"), this);
+}
+
+void DefaultArgumentsCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const auto *S =
+          Result.Nodes.getNodeAs<CXXDefaultArgExpr>("stmt")) {
+    diag(S->getUsedLocation(),
+         "calling a function that uses a default argument is disallowed");
+    diag(S->getParam()->getLocStart(),
+        "default parameter was declared here",
+         DiagnosticIDs::Note);
+  } else if (const ParmVarDecl *D =
+          Result.Nodes.getNodeAs<ParmVarDecl>("decl")) {
+    SourceRange DefaultArgRange = D->getDefaultArgRange();
+
+    if (DefaultArgRange.getEnd() != D->getLocEnd()) {
+      return;
+    } else if (DefaultArgRange.getBegin().isMacroID()) {
+      diag(D->getLocStart(),
+           "declaring a parameter with a default argument is disallowed");
+    } else {
+      SourceLocation StartLocation = D->getName().empty() ?
+              D->getLocStart() : D->getLocation();
+
+      SourceRange RemovalRange(Lexer::getLocForEndOfToken(
+             StartLocation, 0,
+             *Result.SourceManager,
+             Result.Context->getLangOpts()
+           ),
+           DefaultArgRange.getEnd()
+         );
+
+      diag(D->getLocStart(),
+          "declaring a parameter with a default argument is disallowed")
+          << D
+          << FixItHint::CreateRemoval(RemovalRange);
+    }
+  }
+}
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang

clang-tidy/fuchsia/FuchsiaTidyModule.cpp

+//===--- FuchsiaTidyModule.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 "DefaultArgumentsCheck.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// This module is for Fuchsia specific checks.
+class FuchsiaModule : public ClangTidyModule {
+public:
+  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<DefaultArgumentsCheck>(
+        "fuchsia-default-arguments");
+  }
+};
+// Register the FuchsiaTidyModule using this statically initialized variable.
+static ClangTidyModuleRegistry::Add<FuchsiaModule>
+    X("fuchsia-module", "Adds Fuchsia platform checks.");
+} // namespace fuchsia
+
+// This anchor is used to force the linker to link in the generated object file
+// and thus register the FuchsiaModule.
+volatile int FuchsiaModuleAnchorSource = 0;
+
+} // namespace tidy
+} // namespace clang

clang-tidy/tool/CMakeLists.txt

target_link_libraries(clang-tidy
   clangASTMatchers
   clangBasic
   clangTidy
   clangTidyAndroidModule
   clangTidyBoostModule
   clangTidyBugproneModule
   clangTidyCERTModule
   clangTidyCppCoreGuidelinesModule
+  clangTidyFuchsiaModule
   clangTidyGoogleModule
   clangTidyHICPPModule
   clangTidyLLVMModule
   clangTidyMiscModule
   clangTidyModernizeModule
   clangTidyMPIModule
   clangTidyObjCModule
   clangTidyPerformanceModule

clang-tidy/tool/ClangTidyMain.cpp

static int LLVM_ATTRIBUTE_UNUSED LLVMModuleAnchorDestination =
     LLVMModuleAnchorSource;
 
 // This anchor is used to force the linker to link the CppCoreGuidelinesModule.
 extern volatile int CppCoreGuidelinesModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED CppCoreGuidelinesModuleAnchorDestination =
     CppCoreGuidelinesModuleAnchorSource;
 
 // This anchor is used to force the linker to link the GoogleModule.
+extern volatile int FuchsiaModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED FuchsiaModuleAnchorDestination =
+    FuchsiaModuleAnchorSource;
+
+// This anchor is used to force the linker to link the GoogleModule.
 extern volatile int GoogleModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED GoogleModuleAnchorDestination =
     GoogleModuleAnchorSource;
 
 // This anchor is used to force the linker to link the AndroidModule.
 extern volatile int AndroidModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED AndroidModuleAnchorDestination =
     AndroidModuleAnchorSource;

docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- New `fuchsia-default-arguments
+  <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-default-arguments.html>`_ check
+
+  Warns if a function or method is declared or called with default arguments.
+
 - New `google-avoid-throwing-objc-exception
   <http://clang.llvm.org/extra/clang-tidy/checks/google-objc-avoid-throwing-exception.html>`_ check
 
   Add new check to detect throwing exceptions in Objective-C code, which should be avoided.
 
 - New `objc-property-declaration
   <http://clang.llvm.org/extra/clang-tidy/checks/objc-property-declaration.html>`_ check
 
   Add new check for Objective-C code to ensure property
   names follow the naming convention of Apple's programming
   guide.
 
 - New `google-objc-global-variable-declaration
   <http://clang.llvm.org/extra/clang-tidy/checks/google-global-variable-declaration.html>`_ check
 
   Add new check for Objective-C code to ensure global 
   variables follow the naming convention of 'k[A-Z].*' (for constants) 
   or 'g[A-Z].*' (for variables).
 
 - New module `objc` for Objective-C style checks.
 
 - New `objc-forbidden-subclassing
   <http://clang.llvm.org/extra/clang-tidy/checks/objc-forbidden-subclassing.html>`_ check
 
   Ensures Objective-C classes do not subclass any classes which are
   not intended to be subclassed. Includes a list of classes from Foundation
   and UIKit which are documented as not supporting subclassing.

docs/clang-tidy/checks/fuchsia-default-arguments.rst

+.. title:: clang-tidy - fuchsia-default-arguments
+
+fuchsia-default-arguments
+=========================
+
+Warns if a function or method is declared or called with default arguments.
+
+For example, the declaration:
+
+.. code-block:: c++
+
+  int foo(int value = 5) { return value; }
+
+will cause a warning.
+
+A function call expression that uses a default argument will be diagnosed.
+Calling it without defaults will not cause a warning:
+
+.. code-block:: c++
+
+  foo();  // warning
+  foo(0); // no warning
+
+See the features disallowed in Fuchsia at https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md

docs/clang-tidy/checks/list.rst

.. toctree::
    cppcoreguidelines-pro-type-cstyle-cast
    cppcoreguidelines-pro-type-member-init
    cppcoreguidelines-pro-type-reinterpret-cast
    cppcoreguidelines-pro-type-static-cast-downcast
    cppcoreguidelines-pro-type-union-access
    cppcoreguidelines-pro-type-vararg
    cppcoreguidelines-slicing
    cppcoreguidelines-special-member-functions
+   fuchsia-default-arguments
    google-build-explicit-make-pair
    google-build-namespaces
    google-build-using-namespace
    google-default-arguments
    google-explicit-constructor
    google-global-names-in-headers
    google-objc-avoid-throwing-exception
    google-objc-global-variable-declaration
    google-readability-braces-around-statements (redirects to readability-braces-around-statements) <google-readability-braces-around-statements>

docs/clang-tidy/index.rst

 Name prefix            Description
 ====================== =========================================================
 ``android-``           Checks related to Android.
 ``boost-``             Checks related to Boost library.
 ``bugprone-``          Checks that target bugprone code constructs.
 ``cert-``              Checks related to CERT Secure Coding Guidelines.
 ``cppcoreguidelines-`` Checks related to C++ Core Guidelines.
 ``clang-analyzer-``    Clang Static Analyzer checks.
+``fuchsia-``           Checks related to Fuchsia coding conventions.
 ``google-``            Checks related to Google coding conventions.
 ``hicpp-``             Checks related to High Integrity C++ Coding Standard.
 ``llvm-``              Checks related to the LLVM coding conventions.
 ``misc-``              Checks that we didn't have a better category for.
 ``modernize-``         Checks that advocate usage of modern (currently "modern"
                        means "C++11") language constructs.
 ``mpi-``               Checks related to MPI (Message Passing Interface).
 ``objc-``              Checks related to Objective-C coding conventions.
* To restrict the files examined you can provide one or more regex arguments
   ``run-clang-tidy.py clang-tidy/.*Check\.cpp`` will only analyze clang-tidy
   checks. It may also be necessary to restrict the header files warnings are
   displayed from using the ``-header-filter`` flag. It has the same behavior
   as the corresponding :program:`clang-tidy` flag.
 
 * To apply suggested fixes ``-fix`` can be passed as an argument. This gathers
   all changes in a temporary directory and applies them. Passing ``-format``
   will run clang-format over changed lines.
 

test/clang-tidy/fuchsia-default-arguments.cpp

+// RUN: %check_clang_tidy %s fuchsia-default-arguments %t
+
+int foo(int value = 5) { return value; }
+// CHECK-MESSAGES: [[@LINE-1]]:9: warning: declaring a parameter with a default argument is disallowed [fuchsia-default-arguments]
+// CHECK-FIXES: int foo(int value) { return value; }
+
+int f() {
+  foo();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: calling a function that uses a default argument is disallowed [fuchsia-default-arguments]
+  // CHECK-NEXT: note: default parameter was declared here:
+  // CHECK-NEXT: int foo(int value = 5) { return value; }
+}
+
+int bar(int value) { return value; }
+
+int n() {
+  foo(0);
+  bar(0);
+}
+
+class Baz {
+public:
+  int a(int value = 5) { return value; }
+  // CHECK-MESSAGES: [[@LINE-1]]:9: warning: declaring a parameter with a default argument is disallowed [fuchsia-default-arguments]
+  // CHECK-FIXES: int a(int value) { return value; }
+
+  int b(int value) { return value; }
+};
+
+class Foo {
+  // Fix should be suggested in declaration
+  int a(int value = 53);
+  // CHECK-MESSAGES: [[@LINE-1]]:9: warning: declaring a parameter with a default argument is disallowed [fuchsia-default-arguments]
+  // CHECK-FIXES: int a(int value);
+};
+
+// Fix shouldn't be suggested in implementation
+int Foo::a(int value) {
+  return value;
+}
+
+// Elided functions
+void f(int = 5) {};
+// CHECK-MESSAGES: [[@LINE-1]]:8: warning: declaring a parameter with a default argument is disallowed [fuchsia-default-arguments]
+// CHECK-FIXES: void f(int) {};
+
+void g(int) {};
+
+// Should not suggest fix for macro-defined parameters
+#define D(val) = val
+
+void h(int i D(5));
+// CHECK-MESSAGES: [[@LINE-1]]:8: warning: declaring a parameter with a default argument is disallowed [fuchsia-default-arguments]
+// CHECK-FIXES-NOT: void h(int i);
+
+void x(int i);
+void x(int i = 12);
+// CHECK-MESSAGES: [[@LINE-1]]:8: warning: declaring a parameter with a default argument is disallowed [fuchsia-default-arguments]
+// CHECK-FIXES: void x(int i);
+
+void x(int i) {}
+
+struct S {
+  void x(int i);
+};
+
+void S::x(int i = 12) {}
+// CHECK-MESSAGES: [[@LINE-1]]:11: warning: declaring a parameter with a default argument is disallowed [fuchsia-default-arguments]
+// CHECK-FIXES: void S::x(int i) {}
+
+int main() {
+  S s;
+  s.x();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: calling a function that uses a default argument is disallowed [fuchsia-default-arguments]
+  // CHECK-NEXT: note: default parameter was declared here:
+  // CHECK-NEXT: void S::x(int i = 12) {}
+  x();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: calling a function that uses a default argument is disallowed [fuchsia-default-arguments]
+  // CHECK-NEXT: note: default parameter was declared here:
+  // CHECK-NEXT: void x(int i = 12);
+}
 No newline at end of file