Signature Help

Trigger Characters

Registered: (, ), {, }, <, >, ,

Character	Context	Behavior
(	Function call	Show overload signatures
)	Close paren	Update context
{	Brace init	Show overload signatures
}	Close brace	Update context
<	Template args	Show overload signatures
>	Template close	Update context
,	Argument separator	Update active parameter

• Avoid false triggers — don't fire inside comments, string literals, or when defining a function (clangd#51, clangd#289)

  void foo(int x, int y) {  // should NOT trigger signature help
  //       ^^^^^^^^^^^^^ this is a definition, not a call

• new expression with braces should trigger signature help (clangd#1967)

  auto* w = new Widget{800, 600};
  //                   ^ should trigger signature help for Widget constructors

Overload Signatures

Supported

Function overloads

Signature help lists every overload with its parameter list and return type

Supported

Active parameter tracking

The parameter under the cursor is bracketed; the point sits in the second argument

Supported

Member function overloads

A non-const receiver lists both the const and non-const overloads; the trailing const qualifier is not rendered in the label

Supported

Default arguments in the label

Parameters with defaults render their initializer in the signature

Supported

C-style variadic function

Named parameters are listed while the trailing ellipsis is elided from the label

Supported

Variadic template pack

The parameter pack renders as the callee's uninstantiated signature

Supported

Active parameter beyond overload

With the cursor in the second argument, only overloads that declare a second parameter remain

• Template instantiation pattern resolution (shows template pattern, not instantiation)

• Filter const/non-const overload duplicates — don't show both when only one is viable (clangd#50)

  struct Vec {
      int& operator[](size_t);
      const int& operator[](size_t) const;
  };
  Vec v;
  v[0];  // only show non-const overload (v is non-const)

• Prefer user-supplied constructors over compiler-generated ones (clangd#1259)

• Filter dependent overload candidates by arity (clangd#2342)

  template<typename T>
  void process(T& obj) {
      obj.foo(1, 2);  // if T has foo(int) and foo(int,int), only show foo(int,int) as viable
  }

• Better heuristic resolution of dependent overloads (clangd#1083)

• Strip C++23 explicit object parameter from displayed signatures (clangd#2284)

  struct S { void f(this S& self, int x); };
  S s;
  s.f(^  // show "(int x)", not "(this S& self, int x)"

Special Call Contexts

Supportedclangd#726 clangd#2541

Constructors and aggregates

Constructor calls render without a return arrow; aggregate initialization lists the fields in braces

Supported

Function pointer calls

The prototype's parameter names show, not just the types

Supportedclangd#299 clangd#1387

Template argument lists

Template parameters show as the signature; a class template points at its kind, not a return type

Supported

Nested calls

The inner call's help shows at the inner marker and the outer call's help at the outer marker

Supported

Functor call

Invoking an object routes signature help to its operator() overload

Supported

Lambda call

Calling a lambda variable offers the closure's operator() parameters

Supported

New expression

A new-expression's constructor arguments drive signature help

• Inherited constructors — show base class constructors when calling from derived (clangd#1363)

  struct Base { Base(int x, int y); };
  struct Derived : Base { using Base::Base; };
  Derived d(^  // show Base(int x, int y)

• operator[] signature help (clangd#2472)

  std::map<std::string, int> m;
  m[^  // show operator[](const string& key)

• Lambda calls — show lambda name instead of operator() (clangd#86)

  auto validate = [](int x, int max) -> bool { ... };
  validate(^  // show "validate(int x, int max) -> bool", not "operator()(int x, int max)"

• Function pointer calls — show parameter names (clangd#1068, clangd#1729)

  void (*callback)(int status, const char* msg);
  callback(^  // show "(int status, const char* msg)"

• Constructor signature help during object initialization

• Macro function calls — show macro parameters, not the underlying expansion (clangd#795)

  #define CHECK(cond, msg) do { if (!(cond)) fail(msg); } while(0)
  CHECK(^  // show "CHECK(cond, msg)", not "fail(const char*)"

Parameter Display

• Forwarding function parameter resolution — show underlying constructor parameters for std::make_unique, emplace_back, etc. (clangd#517)

  struct Widget { Widget(int width, int height); };
  std::make_unique<Widget>(^  // show "(int width, int height)"

• Parameter pack display (clangd#638)

  template<typename... Args>
  void log(const char* fmt, Args&&... args);
  log("x=%d y=%d", ^  // show "fmt, args..." with active parameter on args

• Prettify standard library parameter names (clangd#736)

  // current:  push_back(const value_type& __x)
  // expected: push_back(const value_type& value)

• Preserve enum class scope in parameter types (clangd#2475)

  enum class Color { Red, Green, Blue };
  void paint(Color c);
  paint(^  // show "(Color c)", not "(c)" with scope stripped

• Show default parameter values

  void open(std::string path, int mode = 0644);
  open("file", ^  // show "int mode = 0644" (active), user knows it can be omitted

Documentation

• Documentation for the active parameter (from @param doc comments)

  /// @param path The file system path.
  /// @param mode POSIX file permission bits.
  void open(std::string path, int mode);
  open("file", ^  // show documentation for mode parameter

• Respect documentationFormat capability (clangd#945)

• Propagate documentation through inherited constructors (clangd#1936)

• Overload set count indicator