DEV Community: Arun Pal

Fixing Clangd "No Locations Found" Error in Neovim for C++ Projects

Arun Pal — Tue, 22 Jul 2025 15:46:25 +0000

The Problem: When Your LSP Can't Navigate Your Code

If you're a C++ developer using Neovim with clangd as your Language Server Protocol (LSP), you might have encountered this frustrating scenario:

You try to go to a definition with gd or <leader>gd
You get "No locations found" error
Autocompletion doesn't work properly
Your LSP seems broken despite having a valid compile_commands.json

This issue is particularly common when:

Your project is built with GCC but you're using clangd (LLVM-based) as your LSP
You're on Ubuntu or other Linux distributions with GCC as the system compiler
Your CMake-generated compile_commands.json looks correct but clangd still fails

Understanding the Root Cause

The issue stems from a fundamental difference between how GCC and Clang handle system headers:

GCC knows where its standard library headers are located (e.g., /usr/include/c++/14)
Clangd (based on LLVM/Clang) doesn't automatically know where GCC's headers are installed
CMake doesn't include system header paths in compile_commands.json because it assumes the compiler knows where they are

This creates a perfect storm where clangd can't parse your code properly because it can't find basic headers like <string>, <vector>, or <map>.

The Symptoms in Your LSP Log

When you check your LSP log (~/.local/state/nvim/lsp.log), you might see errors like:

[pp_file_not_found] Line 1: in included file: 'bits/c++config.h' file not found
[no_member_template] Line 26: no template named 'map' in namespace 'std'
[no_member_suggest] Line 26: no member named 'string' in namespace 'std'

These errors cascade, preventing clangd from building a proper Abstract Syntax Tree (AST) of your code, which breaks navigation, completion, and other LSP features.

The Solution: Enhancing compile_commands.json

Here's a Python script that automatically fixes this issue by enhancing your compile_commands.json with the necessary system include paths:

#!/usr/bin/env python3
"""
enhance_compile_commands.py
Enhances compile_commands.json with proper system includes for clangd
"""
import json
import subprocess
import os
import sys

def get_system_includes():
    """Get system include paths from the compiler"""
    try:
        # Get C++ system includes from GCC
        result = subprocess.run(
            ['g++', '-E', '-x', 'c++', '-', '-v'],
            input='',
            capture_output=True,
            text=True
        )

        lines = result.stderr.split('\n')
        includes = []
        in_include_section = False

        for line in lines:
            if '#include <...> search starts here:' in line:
                in_include_section = True
                continue
            elif 'End of search list.' in line:
                in_include_section = False
                continue
            elif in_include_section and line.strip():
                include_path = line.strip()
                if os.path.exists(include_path):
                    includes.append(f'-I{include_path}')

        return includes
    except Exception as e:
        print(f"Error getting system includes: {e}")
        return []

def clean_include_paths(parts):
    """Remove non-existent include paths"""
    cleaned_parts = []
    skip_next = False

    for i, part in enumerate(parts):
        if skip_next:
            skip_next = False
            continue

        if part == '-I' and i + 1 < len(parts):
            # Check if the next part is the include path
            include_path = parts[i + 1]
            if os.path.exists(include_path):
                cleaned_parts.append(part)
                cleaned_parts.append(include_path)
            else:
                print(f"Removing non-existent include path: {include_path}")
            skip_next = True
        elif part.startswith('-I'):
            # Check if the include path exists
            include_path = part[2:]
            if os.path.exists(include_path):
                cleaned_parts.append(part)
            else:
                print(f"Removing non-existent include path: {include_path}")
        else:
            cleaned_parts.append(part)

    return cleaned_parts

def enhance_compile_commands(input_file, output_file=None):
    """Enhance compile_commands.json with system includes"""
    if output_file is None:
        output_file = input_file

    # Read the original compile_commands.json
    with open(input_file, 'r') as f:
        commands = json.load(f)

    # Get system includes
    system_includes = get_system_includes()
    print(f"Found {len(system_includes)} system include paths")

    # Add system includes to each command
    for entry in commands:
        if 'command' in entry:
            # Split the command into parts
            parts = entry['command'].split()

            # Clean up non-existent paths first
            parts = clean_include_paths(parts)

            # Find where to insert the includes (after the compiler command)
            insert_pos = 1
            for i, part in enumerate(parts):
                if part.startswith('-'):
                    insert_pos = i
                    break

            # Insert system includes
            for include in reversed(system_includes):
                if include not in parts:
                    parts.insert(insert_pos, include)

            # Rebuild the command
            entry['command'] = ' '.join(parts)

    # Write the enhanced compile_commands.json
    with open(output_file, 'w') as f:
        json.dump(commands, f, indent=2)

    print(f"Enhanced compile_commands.json written to {output_file}")

if __name__ == "__main__":
    compile_commands_path = "build/compile_commands.json"

    if len(sys.argv) > 1:
        compile_commands_path = sys.argv[1]

    if not os.path.exists(compile_commands_path):
        print(f"Error: {compile_commands_path} not found")
        sys.exit(1)

    enhance_compile_commands(compile_commands_path)

How to Use the Script

Save the script as enhance_compile_commands.py in your project root
Make it executable: chmod +x enhance_compile_commands.py
Run it after generating your compile_commands.json:

# Generate compile_commands.json with CMake
cd build
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ..
cd ..

# Enhance it with system includes
python3 enhance_compile_commands.py build/compile_commands.json

Setting Up Neovim for Success

Here's a minimal .clangd configuration file for your project root:

CompileFlags:
  CompilationDatabase: build/

Index:
  Background: Build
  StandardLibrary: Yes

Diagnostics:
  UnusedIncludes: Strict
  MissingIncludes: Strict

Completion:
  AllScopes: Yes

And ensure your Neovim LSP configuration includes clangd. Here's an example using Mason and nvim-lspconfig:

require("mason-lspconfig").setup({
    ensure_installed = {
        "clangd"
    },
})

require("lspconfig").clangd.setup {
    cmd = {
        "clangd",
        "--background-index",
        "--clang-tidy",
        "--header-insertion=iwyu",
        "--completion-style=detailed",
        "--function-arg-placeholders=1",
        "--fallback-style=llvm",
        "--log=error",
    },
}

Additional Tips

Clear clangd cache after enhancing compile_commands.json:

   rm -rf ~/.cache/clangd

Set LSP log level to reduce noise in Neovim:

   vim.lsp.set_log_level("ERROR")

Verify the fix by running clangd manually:

   clangd --check=path/to/your/file.cpp

Why This Works

The script works by:

Querying GCC for its internal include search paths using -E -x c++ -v
Adding these paths to every compilation command in compile_commands.json
Cleaning up non-existent paths that might cause parsing errors
Creating a complete compilation database that clangd can use effectively

This bridges the gap between GCC (your build compiler) and clangd (your LSP), enabling proper code parsing and all LSP features.

Common Variations

Depending on your system, you might need to adjust the script:

Replace g++ with clang++ if using Clang as your build compiler
Add support for C files by also querying gcc for C includes
Handle cross-compilation by specifying the target compiler

Conclusion

This issue affects many C++ developers using modern development tools, but the solution is straightforward once you understand the problem. By enhancing your compile_commands.json with system include paths, you can enjoy all the powerful features of clangd in Neovim, regardless of which compiler you use for building.

The beauty of this solution is that it's:

Automatic: Run once after CMake configuration
Portable: Works across different GCC versions
Non-invasive: Doesn't modify your build system
Reusable: Can be integrated into your build workflow

Happy coding, and may your LSP always find your definitions!

Have you encountered similar issues with clangd? What other LSP challenges have you faced? Share your experiences in the comments below!

How I cleared CKA exam?

Arun Pal — Fri, 30 Sep 2022 17:18:36 +0000

Recently I cleared CKA exam by scoring 83/100 and now wanted to share my tips and tricks which might help you to crack it.

Preparation

Please note before going CKA exam you should have a good understanding about linux administrator and container or docker.
You can start mumshad cka course from kodekloud or buy cka exam bundle during exam registration. Both are good resource for preparation purpose.
Wanted to get better knowledge about kubernetes then you can read blog of iximiuz
Along with above you can also refer youtube video of tech world with nana

Practice, practice and practice

Along with theoretical knowledge from above preparation material, do as much as lab/exercise you can.
Along with exam buy, you will also get simulator like real exam for practice from killer.sh . You get two sessions in the same simulator, both have the same questions. So do as much practice as you can.
I feel questions provided from this freecode blog are useful for practice purpose.

Tips for exam

Time is key so use it wisely, don't stuck in any single question for long time instead flag it and try to solve it later if time permit.
Please note during exam they provide their own PSI browser so all bookmarks related to kubernetes won't work.
Before starting on first question split your screen vertically in three part such as 20% for question part , 40% for terminal, 40% for firefox browser. Make sure to use as large monitor as possible mine was 24inch
Most important to update your .bashrc with following snippet

alias k='eval kubectl'
alias kf='kubectl create -f'
alias kg='kubectl get'
export do='--dry-run=client -o yaml'
export ex='--help | sed -n "/Examples:/,/^[A-Z]/p"' # eval in alias of k is important to execute ex
alias kc='kubectl config set-context '

This way you will save lots of time, you can use above command as below

# To create resource from file as pod.yaml
kf pod.yaml
# To show all service in default namespace
kg svc
# Create yaml file before creating resource
kubectl create deployment my-deploy --replicas 2 --image nginx $do > mydeploy.yaml
# See examples from help
k create role $ex

Here is my certificate

Best of luck for your exam.

If you want to get introductory information before deciding to go for exam , I would suggest to take a look on this article Kubernetes – Basic Concepts

How do I score 85/100 on my first attempt in LFCS exam

Arun Pal — Sat, 12 Feb 2022 05:46:51 +0000

Brief about the Certification

If you want to demonstrate your system administration skills to your current/future employer then I would highly recommend to do LFCS certification. The exam consists of performance-based items that simulate on-the-job tasks and scenarios faced by sysadmins in the real world. Candidates can select either Ubuntu 18 or CentOS 7.

How I started

On Oct21 I have decided to take a jump in my DevOps journey and enrolled myself for cloud engineer bootcamp provided by Linux Foundation.
In that bootcamp there are 5 courses and 2 certifications. LFCS was one of that. If you look into there timeline, then after completing LFS201 and LFS211 you are ready to give exams. It took me 3 months i.e. till the beginning of Jan to complete both the course. ( It took me long as I have my fulltime job also as a DevOps Engineer).

After that I started looking for some blogs and other people's preparation guide on how to clear LFCS certification.

Then I did a lot of practices on different problems of various topics.

Here is the checklist

Essential Commands 25%
Operation of Running Systems 20%
User and Group Management 10%
Networking 12%
Service Configuration 20%
Storage Management 13%

Also you can get full Preparation guide from Linux Foundation

After having good practice I decided to give my exam on 6th Feb 2021(Sunday early Morning IST).

How it is going!

And here is the result (😃)

Here are the few important things which I learned during my preparation.

man -k <keyword> is your go to guy to get any clue about any command/topic.
Don't memorise the command instead practice and understand the concept.
Keep practice on your virtual machine and not on any bare metal box. ( I have crashed my VM many times due to wrong configurations in partition 😁 )
When you practice don't do google try to always look in man. Think like what if I forgot what needs to be write in config or what will be command then where I have to look.( Most probably there will be default conf under etc or you can look man).
Remember questions are not that much tough in the exam, It is the time where people usually fail. I myself not able to attempt 2 questions(which is of marks). So don't stick on a single question for more than 5-7 mins.

Lastly solve as much problem as you can, complete the Practice Questions. All the best.

Send Covid slot alerts on telegram channel

Arun Pal — Sat, 27 Nov 2021 17:02:48 +0000

Here I will explain how you can create a telegram bot using which you can send covid slots update on a telegram channel.

The whole post will be of two part, first we will see how can we create a bot and send a message to a telegram channel.

How to send a message on telegram channel using a bot

Steps :

create your bot, by sending a message to @botfather
add the bot to your channel. stackoverflow
Get channel id by

curl https://api.telegram.org/bot<bot_token>/getUpdates| python -m json.tool

Replace bot_token with token generated from step 1.
You need to see id from chat section such as

                "chat": {
                    "id": xxxxxxxxxxx,
                    "title": "Test_call",
                    "type": "channel"
                },

Write a code to send message to your channel using bot API , for simplicity you can use following function

import requests
def sendToTelegram(message,chat_id,bot_token):
    response = requests.post(
            url=f'https://api.telegram.org/bot{bot_token}/sendMessage',
            data={"chat_id": chat_id, "text": message, "disable_notification": True }
            ).json()

Note : You can use bots to send message to channels. But there is some limitation, like size of files.

Now let's move to the second part of post where we will see how to use co-win api and how we will format output based on our requirements.

Use Co-win API to find the available slot

If you refer to cowin site then you will get there are 3 ways to search for slots

By District

We will call cowin API to get slot by district

    # Let's read from cowin
    headers = {
            'authority': 'cdn-api.co-vin.in',
            'sec-ch-ua': '"Google Chrome";v="89", "Chromium";v="89", ";Not A Brand";v="99"',
            'accept': 'application/json, text/plain, */*',
            'sec-ch-ua-mobile': '?0',
            'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36',
            'origin': 'https://www.cowin.gov.in',
            'sec-fetch-site': 'cross-site',
            'sec-fetch-mode': 'cors',
            'sec-fetch-dest': 'empty',
            'referer': 'https://www.cowin.gov.in/',
            'accept-language': 'en-IN,en-GB;q=0.9,en-US;q=0.8,en;q=0.7',
            }

    params = (
            ('district_id', district_id),
            ('date',date),
            )
    response = requests.get('https://cdn-api.co-vin.in/api/v2/appointment/sessions/public/calendarByDistrict', headers=headers, params=params)

By PIN

This will be similar to above request , you just need to update params and API path

params = (('pincode', pincode),
           ('date',date),
          )

response = requests.get('https://cdn-api.co-vin.in/api/v2/appointment/sessions/public/calendarByPin', headers=headers, params=params)

On the Map :

We are not going to cover this

Once you get the data from co-win api you need to parse it , and change it as per your requirements.

The data cowin api will give have both free and paid slots. Also it will include all type of vaccine(covishield, covaxin etc). So you may want to filter it out based on your requirement

    import pandas as pd
    result_df = pd.DataFrame()
    # First check if response is correct or not
    if response.status_code == 200:
        dict_response = json.loads(response.text)
        if 'centers' in dict_response :
            df = pd.DataFrame(dict_response['centers'])
                    # Here I'm applying filters
            df = df[df.fee_type == "Free"]
            result_df = result_df.append(df, ignore_index = True)
        else:
            print(dict_response,type(dict_response))
    else:
            # If api request failed    
        print(response.status_code,response.text)

Now Create a message from above output which you wants to send on telegram channel

    age = 18 # Since I want to select slots where minimum age is 18 not 45
    message = ""
    for center_id, df in result_df.groupby("center_id"):
        for index, row in df.iterrows():
            available_capacity1 = 0
            available_capacity2 = 0
            for s in row["sessions"]:
                if s["min_age_limit"] == age:
                    available_capacity1 = s["available_capacity_dose1"]
                    available_capacity2 = s["available_capacity_dose2"]
            if available_capacity1 + available_capacity2 > 0:
                message+="Dose 1: %s,Dose 2: %s,  Slot Available at %s, pincode %s\n"%(available_capacity1,available_capacity2,row['name'],row['pincode'])
    # chances are there no slot available
    if len(message) > 0:
        return message

Application

Using above snippets you can create and send alerts on your mobile as soon as any slot is available in your area.

Using above code I created few channels , which helped more than 6000 peoples to find the slots as soon as possible because of timely notification.

Here are few screenshots of my channels

3 MS teams tips to boost your productivity

Arun Pal — Wed, 20 Oct 2021 15:06:08 +0000

The popularity of MS teams has been increased tremendously because of lockdown. Today most of the organization uses MS teams for team-level communication and chat.

Here I'm sharing a few of simple yet mostly unknown apps/tricks that can increase your work productive

1. Remind

Set a reminder for yourself, a group chat, or a channel by simply sending a message to the Remind bot.

Very handy to use, just type "@remind "Deploy code" on Monday at 8pm" in a group chat or a channel and it will remind you there. I use remind app almost daily.

Some examples are :

"Project Meeting" every monday at 4pm
"turn in all reports" on the last weekday of every month
"update server" every Monday, Wednesday, Saturday at 10am

You can also remind yourself about any Teams message.

How to use:

Just click on Apps(see left bottom corner of your msteams app/browser), search for remind. Click Add and it's done. on typing help to remind bot you will get a better idea of how to use it.

2. quicklink

You can easily add links such as some company's ip, custom webservices or research paper's link etc. in the group chat or channel itself.
Again very easy to use. You can add this too in the same way as remind app.

3. Incoming Webhook

Using webhook you can send custom messages on teams channel through MS teams API.

For example

Notify on teams once service completed it's job.
Notify if some x service gets down.
Notify on teams channel if someone tweeted about some XYZ stuff etc.

Note: It sends messages to the channel only.

How to use it :

Go to apps, search for incoming webhook. Now here it will ask on which channel you want to add webhook. Once added it will generate a URL.
On that URL, you can send messages using HTTP requests(for ex using curl etc).

For more information :

Tell me in comments which ms teams app/tricks you use more to increase your productivity.