mcpp-language-server/mcpp.toml at main · Sunrisepeak/mcpp-language-server · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
# A workspace rooted in the server (.agents/docs/design.md §2).
#
# Split by DEPENDENCY SET, not by taste: mcpp compiles a package's modules once and links them into
# every executable of that package, so anything a tool needs and the server must not carry (a
# network client, an archive reader) lives in a member the server does not depend on.
#
#   modules/base                     shared by the server, the tools and the gateway
#   modules/toolrun                  how the server and the tools run a project's programs
#   modules/pack                     packaging only: tinyhttps, libarchive
#   tools/devtools                   mcppls-devtools, the one entry for project work (docs/93-devtools.md)
#   tools/model-gateway              mcppls-model
#   tests/harness                    how a case drives the server through mcppls-conformance
#   tests/cts                        mcppls-cts, the conformance cases (tests/cts/README.md)
#   tests/bench                      mcppls-bench, the measurements (tests/bench/README.md)
#
# The root package stays the server, so `mcpp build` and `mcpp test` mean what they meant; a
# member is reached with `-p` (`mcpp run -p devtools -- payload`), and `--workspace` reaches all.
[workspace]
members = [
    "modules/base",
    "modules/toolrun",
    "modules/pack",
    "tools/devtools",
    "tools/model-gateway",
    "tests/harness",
    "tests/cts",
    "tests/bench",
]

# THE PLATFORM OF EVERY TARGET (mcpp SPEC-013): openkal-platform states the C library
# (openkal-musl) and the C++ run-time (openkal-llvm-runtime) above openkal, the toolchain, and for
# an ok image (`<arch>-openkal`) its tools, link, seal and runner. The ok images take it here too:
# The platform is one release (design 2026-11-07, D20): the payload this version ships is built over
# one version group, openkal-platform 0.24.4, which names OpenKal 0.24, musl 0.28.1, runtime 0.19.2
# and image 0.5.3 (okrun enters an image in its convention's floating-point state). System triples use its hosted arrangement; images
# use its standalone runtime. The Windows hosted target is x86_64-windows-gnu.
[workspace.target.'cfg(any(linux, macos, windows, os = "openkal"))']
platform = "openkal-platform@0.24.4"

# 2026.11.8.1: a test file of mtest's objects needs no `main` (mtest's entry begins it), and a framework
# that is a dependency and a dev-dependency offers its beginning once. 2026.11.9.1: a Mach-O image links
# its C library first, so an mtest case's registration runs after openkal-musl is up on hosted macOS.
[workspace.package]
mcpp = ">=2026.11.9.1"

# One version of each third-party package for every member, each named by its identity (namespace,
# then name) and an exact release.
[workspace.dependencies]
mcpplibs.cmdline          = "0.0.2"
mcpplibs.tinyhttps        = "0.3.1"
# libarchive and xxHash as C++ modules: their mwrap wrappers, whose implementations are
# compat.libarchive and compat.xxhash (mcpp-index docs/mwrap.md).
mcpplibs.mwrap.libarchive = "3.8.7"
mcpplibs.mwrap.xxhash     = "0.8.3"
# The operating-system layer: mcpplibs.os over openkal (mcpp design 2026-10-26 part 2). The
# openkal implementation of each system is os's dependency, named by it; no program here names it.
# 0.3.1 reads a name in Windows' long spelling as the name it spells.
mcpplibs.os               = "0.4.1"
nlohmann.json             = "3.12.0"
# The test library every package's tests are written with, and the conformance cases (tests/cts):
# mcpp-community/mtest, which speaks the mtest protocol to mcpp, mtest and the editors.
mcpplibs.mtest            = "0.6.3"
"mcpplibs.mtest.manifest" = "0.6.3"

[package]
name        = "mcpp-language-server"
version     = "0.23.0"
description = "Compiler-agnostic C++ modules language server"
license     = "Apache-2.0"
authors     = ["Sunrisepeak"]
repo        = "https://github.com/Sunrisepeak/mcpp-language-server"

[build]
sources = ["src/**/*.cppm", "src/**/*.cpp"]
# The server imports three libSystem symbols, all of them macOS 10.12+; clangd in the payload is
# built for 12.0. Honoured when cross-compiling from Linux since mcpp 2026.9.24.1 (mcpp#685).
macos_deployment_target = "12.0"

# Every executable shares every module under src/.
[targets.mcppls]
kind = "bin"
main = "src/main.cpp"

[targets.mcppls-conformance]
kind = "bin"
main = "src/bin/conformance.cpp"

[targets.mcppls-lspgen]
kind = "bin"
main = "src/bin/lspgen.cpp"

# Stands in for mcpp in conformance fixtures: the build-database contract of mcpp-community/mcpp#636.
[targets.mcppls-mock-mcpp]
kind = "bin"
main = "src/bin/mockmcpp.cpp"

# Stands in for the mcppls-model gateway in tests: tools/model-gateway/PROTOCOL.md over stdin/stdout.
[targets.mcppls-mock-model]
kind = "bin"
main = "src/bin/mockmodel.cpp"

[workspace.toolchain]
default = "llvm@23.1.3"

# The C library and the C++ run-time are the platform's (the workspace's `platform` above).
[dependencies]
mcpplibs.cmdline.workspace      = true
mcpplibs.os.workspace           = true
# clangd names a module unit's lock by the XXH3 digest of its path (engine::clangd::unit_lock_name).
mcpplibs.mwrap.xxhash.workspace = true
nlohmann.json.workspace         = true
mcppls-base                     = { path = "modules/base" }
mcppls-toolrun                  = { path = "modules/toolrun" }

[dev-dependencies]
mcpplibs.mtest.workspace = true

# The server's unit tests (tests/unit, tests/isolated); the conformance cases are the member
# tests/cts. The files of one directory are one program (mcpp 2026.11.8.1), run as a process per file
# of its cases: tests/unit begins at test_conformance.cpp, whose `main` is also the server the
# conformance runner measures; a test that runs again with a cache of its own is a directory of
# tests/isolated.
[test]
discover = ["tests/**/*.cpp", "!tests/cts/**", "!tests/bench/**", "!tests/harness/**"]
programs = "directory"

# An ok image (`<arch>-openkal`) declares nothing: its platform, openkal-platform, supplies the C
# library and the C++ run-time in their image form, the link, okld's seal and okrun, and packs every
# architecture into one package (`mcpp pack --target x86_64-openkal`, docs/92-release.md).


# What packaging needs, declared rather than fetched at runtime.
#
# `mcppls-devtools` drives Node (the VS Code extension is TypeScript), Rust (a Zed extension is a
# crate compiled to WebAssembly) and Gradle (the CLion plugin is a Gradle project, and xim:gradle
# brings the JDK it runs on). None of them is a library this project links, so none is a
# `[dependencies]` entry: they are tools the environment has to contain. A developer configures
# nothing -- `mcpp run -p devtools` provisions what is missing before it runs.
#
# `when = "dev"` rather than `"run"`: `run` also covers `mcpp test`, which needs none of them, and
# `dev` does not reach a consumer of this package. `version = ""` means any version.
[workspace.xlings.workspace]
"xim:node"   = { version = "", when = "dev" }
"xim:rust"   = { version = "", when = "dev" }

# Gradle is behind a feature: `[workspace.xlings.workspace]` is provisioned as a set, so an unconditional
# entry would make every `mcpp run` in this project wait for it -- or fail where the index lacks
# it. Only someone building the CLion plugin should pay for it:
#
#   mcpp run --features clion -p devtools -- extension --editor clion
[features]
clion = {}

[feature-xlings.clion]
"xim:gradle" = { version = "", when = "dev" }

# The built-in release profile (-O2, no -g), plus -s: the executables ship without their symbol
# table, 1.3 MB less per platform. Nothing in the server symbolizes its own stack, so nothing reads
# it; a crash is reproduced from a local build. Restated whole because a [profile.<built-in>]
# replaces the built-in rather than adding to it.
[workspace.profile.release]
opt   = 2
debug = false
strip = true