vvv

How to use clangd C/C++ LSP in any project

tl;dr: If you want to just know the method, skip to How to section

Clangd is a state-of-the-art C/C++ LSP that can be used in every popular text editors like Neovim, Emacs or VS Code. Even CLion uses clangd under the hood. Unfortunately, clangd requires compile_commands.json to work, and the easiest way to painlessly generate it is to use CMake.

For simple projects you can try to use Bear - it will capture compile commands and generate compile_commands.json. Although I could never make it work in big projects with custom or complicated build systems.

But what if I tell you you can quickly hack your way around that, and generate compile_commands.json for any project, no matter how compilcated? I have used that way at work for years, originaly because I used CLion which supported only CMake projects - but now I use that method succesfully with clangd and Neovim.

vvv

Commit Message Guidelines

Short (72 chars or less) summary

More detailed explanatory text. Wrap it to 72 characters. The blank
line separating the summary from the body is critical (unless you omit
the body entirely).

Write your commit message in the imperative: "Fix bug" and not "Fixed
bug" or "Fixes bug." This convention matches up with commit messages

vvv

#!/usr/bin/env stack
{- stack --resolver lts-9.21 script
       --package shelly --package text
 -}
{-# OPTIONS_GHC -Wall -Werror #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ExtendedDefaultRules #-}
{-# OPTIONS_GHC -fno-warn-type-defaults #-}

import           Shelly

vvv

#!/usr/bin/env stack
-- stack --resolver lts-9.21 script --package loch-th
{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -Wall -Werror #-}

import Debug.Trace.LocationTH (check)
import System.Environment (getArgs)

main :: IO ()
main = do

vvv

#!/usr/bin/env stack
-- stack --resolver lts-11.2 script
{-# OPTIONS_GHC -Wall -W -Werror #-}

data Foo = Foo
  { fooInt :: Int
  , fooBar :: Bar
  } deriving Show

data Bar = Bar Baz

vvv

{-# OPTIONS_GHC -Wall -Werror #-}

module DaPhone where

import Data.Char (isUpper, toLower)
import Data.List (elemIndex, foldl', intersperse)
import Data.Maybe (catMaybes)

data DaPhone = DaPhone [String]
  deriving (Eq, Show)

vvv

import Data.Foldable (foldl')
import Debug.Trace (trace)

prnEqual :: (Eq a) => a -> a -> IO ()
prnEqual a b = if a == b then print "True" else print "False"

-- Note the absence of parentheses around `Eq a` and having exactly one `print`.
prnEqual' :: Eq a => a -> a -> IO ()
prnEqual' a b = print $ if a == b then "True" else "False"

vvv

{-- XXX Your definition of `checkChar` is okay, but the abstraction itself
 -- is very odd.  It is fine as an exercise of using "do" notation and
 -- `return`. In real code though explicit statements are both short and
 -- expressive (see lines 21-22).
checkChar :: IO Bool
checkChar = do
    c <- getChar
    return (c == 'y')
--}

vvv

listsum :: Num a => [a] -> a
listsum [] = 0
listsum (x:xs) = x + listsum xs

main :: IO ()
main = print $ listsum [1..5]

vvv

{-# LANGUAGE GADTs #-}
module Program where
--
-- The Operational Monad Tutorial:
-- http://apfelmus.nfshost.com/articles/operational-monad.html
--

-- GADT
data Program instr a where
    Then   :: instr a -> (a -> Program instr b) -> Program instr b