feat: add haskell-language-server 2.14.0.0 (#214)

* feat: add haskell-language-server 2.14.0.0

Add package for the Haskell Language Server (HLS), the official LSP
implementation for Haskell. Builds from source using GHC + Cabal with
dynamic linking, copying the binary and all required shared libraries
via ldd dependency resolution.

- Source: GitHub tag 2.14.0.0 with automatic extraction
- Build deps: base, cabal, ghc
- Runtime deps: glibc
- Network access enabled for cabal dependency index updates
- Includes standalone version check test

* fix: restrict dynamic library bundling to Haskell-specific libs

* fix(haskell-language-server): add missing build deps and disable test/benchmark builds

The HLS cabal.project ships with tests:True and benchmarks:True, which makes
cabal resolve and compile test/benchmark deps for every transitive dependency
— a major cost and failure surface for a 16+ minute build. Pass
--disable-tests --disable-benchmarks to build only the executable.

Also add alex, happy, and zlib as explicit build_deps. alex and happy are in
ghc's build_deps (not runtime_deps), so they aren't injected into downstream
builds — cabal would otherwise have to download and compile them from Hackage.
zlib provides the C library needed by HLS's Haskell dependencies.

* fix(haskell-language-server): set CABAL_DIR and capture build errors

Without CABAL_DIR, cabal has no writable home for its config, package index,
and build store in the sandboxed build environment — the most likely root
cause of the 17-minute build failures. Every other Haskell package in the
repo (tamarin-prover, stack) sets this; HLS was the only one that didn't.

Also add --with-compiler for explicitness, -v1 for verbose output, and an
error-capture block (matching tamarin-prover's pattern) that extracts the
real compile/link error on failure instead of a bare "build failed" exit.

* fix(haskell-language-server): use cabal-level parallelism to avoid OOM

Replace --ghc-options="-j$(nproc)" (per-module GHC parallelism) with
--jobs="$(nproc)" (per-package cabal parallelism). HLS is a massive
project — running nproc GHC instances each with nproc internal module
threads exhausts memory on the build host. Cabal-level parallelism
compiles packages concurrently while keeping module compilation
sequential within each package, matching the tamarin-prover build.

* fix(haskell-language-server): add gmp, libffi, zlib to runtime_deps

The HLS binary links against libgmp, libffi, and libz (GHC runtime
dependencies), but runtime_deps only declared glibc — causing the
missing-runtime-deps and standalone-test post-build checks to fail.
Move zlib from build_deps to runtime_deps (runtime_deps are injected
into the build env, so it covers both roles), and add gmp + libffi
matching GHC's own runtime_deps.

* fix(haskell-language-server): fix alex/happy version detection for cabal

Cabal installs alex/happy from Hackage as build-tool-depends, but the
installed binaries link against GHC's shared libraries (libHSrts etc.)
which aren't on the default library search path — so they fail to run
and cabal reports "version could not be determined" (Cabal-1008).

Two fixes:
- Add GHC's libdir to LD_LIBRARY_PATH so cabal-installed build tools
  can actually execute
- Pass --with-alex/--with-happy pointing at the pre-installed system
  versions so cabal uses those for version checks instead of its own
  broken copies

* fix(haskell-language-server): let cabal install its own alex/happy

The system alex/happy were built with ghc-bootstrap 9.8.1, so their
template files live in /usr/share/x86_64-linux-ghc-9.8.1/... — wrong
GHC version. Passing --with-alex/--with-happy made cabal use those
binaries, which then failed looking for templates in the 9.8.1 data
dir. Remove the --with-* flags so cabal installs its own alex/happy
from Hackage (built with 9.10.3, correct data dir). The LD_LIBRARY_PATH
fix ensures those cabal-installed tools can actually execute.

* fix(haskell): ship alex/happy template files and use them in HLS

alex and happy only captured their binary (usr/bin/alex, usr/bin/happy)
as OutputBin — the template files that ./Setup copy installs to
usr/share/x86_64-linux-ghc-<version>/... were discarded. Without the
templates, the tools fail with "openFile: does not exist" when any
downstream package uses them.

Add a data OutputData (usr/share/**) to both alex and happy so the
template files ship with the package. Then use --with-alex/--with-happy
in the HLS build to point cabal at the pre-packaged versions instead of
letting it download and build its own copies from Hackage — those
copies were the source of the "version could not be determined"
(Cabal-1008) failures.

alex/happy are standalone code generators; they don't need to match
the downstream GHC version, they just need their template files at
the hardcoded path.

---------

Co-authored-by: edge-delta[bot] <226719692+edge-delta[bot]@users.noreply.github.com>

Author: 0chroma

packages/alex/build.ncl

@@ -1,4 +1,4 @@
-let { BuildSpec, Local, OutputBin, Source, .. } = import "minimal.ncl" in
+let { BuildSpec, Local, OutputBin, OutputData, Source, .. } = import "minimal.ncl" in
 let base = import "../base/build.ncl" in
 let bash = import "../bash/build.ncl" in
 let ghc-bootstrap = import "../ghc-bootstrap/build.ncl" in
@@ -34,6 +34,7 @@ let version = "3.5.4.2" in
 
   outputs = {
     alex = { glob = "usr/bin/alex" } | OutputBin,
+    data = { glob = "usr/share/**" } | OutputData,
   },
 
   attrs = {

packages/happy/build.ncl

@@ -1,4 +1,4 @@
-let { BuildSpec, Local, OutputBin, Source, .. } = import "minimal.ncl" in
+let { BuildSpec, Local, OutputBin, OutputData, Source, .. } = import "minimal.ncl" in
 let base = import "../base/build.ncl" in
 let bash = import "../bash/build.ncl" in
 let ghc-bootstrap = import "../ghc-bootstrap/build.ncl" in
@@ -34,6 +34,7 @@ let version = "1.20.1.1" in
 
   outputs = {
     happy = { glob = "usr/bin/happy" } | OutputBin,
+    data = { glob = "usr/share/**" } | OutputData,
   },
 
   attrs = {

packages/haskell-language-server/build.ncl

@@ -0,0 +1,71 @@
+let { Attrs, BuildSpec, Local, Needs, OutputBin, OutputLib, Source, Test, .. } = import "minimal.ncl" in
+
+let alex = import "../alex/build.ncl" in
+let base = import "../base/build.ncl" in
+let cabal = import "../cabal/build.ncl" in
+let ghc = import "../ghc/build.ncl" in
+let glibc = import "../glibc/build.ncl" in
+let gmp = import "../gmp/build.ncl" in
+let happy = import "../happy/build.ncl" in
+let libffi = import "../libffi/build.ncl" in
+let zlib = import "../zlib/build.ncl" in
+
+let version = "2.14.0.0" in
+
+{
+  name = "haskell-language-server",
+
+  build_deps = [
+    { file = "build.sh" } | Local,
+    {
+      url = "https://github.com/haskell/haskell-language-server/archive/refs/tags/%{version}.tar.gz",
+      sha256 = "02fdd2ea8048cddce0872f78fcc4ba15558f751333c97d24b9abadac8ee27dcb",
+      extract = true,
+      strip_prefix = "haskell-language-server-%{version}",
+    } | Source,
+    base,
+    ghc,
+    cabal,
+    alex,
+    happy,
+  ],
+
+  runtime_deps = [glibc, gmp, libffi, zlib],
+
+  needs =
+    {
+      dns = {},
+      internet = {},
+    } | Needs,
+
+  cmd = "./build.sh",
+
+  build_args = {
+    include version,
+  },
+
+  outputs = {
+    hls = { glob = "usr/bin/haskell-language-server" } | OutputBin,
+    libs = { glob = "usr/lib/*.so*" } | OutputLib,
+  },
+
+  attrs =
+    {
+      upstream_version = version,
+      source_provenance = {
+        category = 'GithubRepo,
+        owner = "haskell",
+        repo = "haskell-language-server",
+      },
+      build_cost_multiple = 4,
+    } | Attrs,
+
+  tests = {
+    version_check =
+      {
+        class = 'Standalone,
+        test_deps = [],
+        cmds = [["haskell-language-server", "--version"]],
+      } | Test,
+  },
+} | BuildSpec

packages/haskell-language-server/build.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+set -euo pipefail
+
+# The source tarball is already extracted with strip_prefix, so we're in the source root
+
+# cabal needs a writable HOME for its config, package index, and build store.
+export CABAL_DIR="$PWD/.cabal-home"
+mkdir -p "$CABAL_DIR"
+
+# Build HLS for the GHC version available in the sandbox
+export GHC="$(command -v ghc)"
+export CABAL="$(command -v cabal)"
+
+# GHC's shared libraries (libHSrts, etc.) aren't on the default library search
+# path. The system alex/happy (from build_deps) link against GHC's shared libs
+# and need them to run. We use --with-alex/--with-happy to point cabal at the
+# pre-packaged versions instead of letting cabal download and build its own
+# from Hackage — those packages already ship their template files as a data
+# output, so they work with any GHC version.
+GHC_LIBDIR="$(ghc --print-libdir)"
+export LD_LIBRARY_PATH="${GHC_LIBDIR}:${LD_LIBRARY_PATH:-}"
+
+# Update cabal package index
+cabal update
+
+# Build HLS with the available GHC version. The cabal.project ships with
+# tests:True and benchmarks:True, which makes the solver consider test/benchmark
+# deps for every transitive dependency — pass --disable-tests/--disable-benchmarks
+# to build only the executable.
+set +e
+cabal build \
+  --disable-tests \
+  --disable-benchmarks \
+  --with-compiler="$(command -v ghc)" \
+  --with-alex="$(command -v alex)" \
+  --with-happy="$(command -v happy)" \
+  --jobs="$(nproc)" \
+  -v1 \
+  exe:haskell-language-server 2>&1 | tee /tmp/hls-build.log
+rc=${PIPESTATUS[0]}
+set -e
+if [ "$rc" -ne 0 ]; then
+    echo "===== cabal build failed (rc=$rc) — real error: ====="
+    grep -iE "\.hs:[0-9]+:[0-9]+: error|error:\s*\[GHC|error:\s*\[Cabal|undefined reference|cannot find -l|panic|internal error|cannot satisfy|conflict|could not be determined|Failed to build" /tmp/hls-build.log | tail -25 \
+        || echo "(no error text captured)"
+    tail -25 /tmp/hls-build.log
+    exit 1
+fi
+
+# Install to OUTPUT_DIR
+mkdir -p "$OUTPUT_DIR"/usr/bin
+mkdir -p "$OUTPUT_DIR"/usr/lib
+
+# Find and copy the built binary from cabal's build directory
+HLS_BIN=$(cabal list-bin exe:haskell-language-server)
+cp "$HLS_BIN" "$OUTPUT_DIR"/usr/bin/
+
+# Copy all shared Haskell libraries the binary depends on
+for lib in $(ldd "$HLS_BIN" | grep '\.so' | awk '{print $3}'); do
+  if [ -n "$lib" ] && [ -f "$lib" ]; then
+    libname="${lib##*/}"
+    # Only copy Haskell-specific libraries (libHS*) to avoid bundling standard system glibc/loader libraries
+    if [[ "$libname" == libHS* ]]; then
+      cp "$lib" "$OUTPUT_DIR"/usr/lib/
+    fi
+  fi
+done