zls を workspace/configuration と workspace/didChangeConfiguration に対応させたい

const method_map = .{ 1, 2, 3};

const std = @import("std");
const expect = std.testing.expect;

pub fn main() void {
    var arr = .{1, 2, 3};

    expect(arr[0] == 1);
    expect(arr[1] == 2);
    expect(arr[2] == 3);
}

const method_map = .{
    // ...
    .{ "workspace/didChangeConfiguration", requests.DidChangeConfiguration, didChangeConfigurationHandler }
};

const config = @import("config.zig");

pub const DidChangeConfiguration = struct {
    params: struct {
        // settings: anytype,
        settings: config,
    },
};

const config = @import("config.zig");

pub const DidChangeConfiguration = struct {
    params: struct {
        settings: config,
    },
};

/**
 * The parameters of a change configuration notification.
 */
export interface DidChangeConfigurationParams {
    /**
     * The actual changed settings
     */
    settings: any;
}

pub const Request = struct {
    jsonrpc: []const u8 = "2.0",
    id: RequestId,
    method: []const u8,
    params: RequestParams,
};

// もし、switch で使うなら、 union(enum) にする
pub const RequestParams = union(enum) {
    ContigurationParams: ConfigurationParams,
};

pub const ConfigurationParams = struct {
    items: []ConfigurationItem;
};

pub const ConfigurationItem = struct {
    scopeUri: ?[]const u8,
    section: ?[]const u8,
};

    /// Runs this language service.
    pub fn run(mut self) -> i32 {
        loop {
            match self.handle_message() {
                ServerStateChange::Continue => (),
                ServerStateChange::Break { exit_code } => return exit_code,
            }
        }
    }

    pub(crate) fn send_request<R: lsp_types::request::Request>(
        &mut self,
        params: R::Params,
        handler: ReqHandler,
    ) {
        let request = self.req_queue.outgoing.register(R::METHOD.to_string(), params, handler);
        self.send(request.into());
    }
    pub(crate) fn complete_request(&mut self, response: lsp_server::Response) {
        let handler = self.req_queue.outgoing.complete(response.id.clone());
        handler(self, response)
    }

pub(crate) type ReqHandler = fn(&mut GlobalState, lsp_server::Response);
pub(crate) type ReqQueue = lsp_server::ReqQueue<(String, Instant), ReqHandler>;

use crate::{ErrorCode, Request, RequestId, Response, ResponseError};

impl<O> Outgoing<O> {
    pub fn register<P: Serialize>(&mut self, method: String, params: P, data: O) -> Request {
        let id = RequestId::from(self.next_id);
        self.pending.insert(id.clone(), data);
        self.next_id += 1;
        Request::new(id, method, params)
    }
    pub fn complete(&mut self, id: RequestId) -> O {
        self.pending.remove(&id).unwrap()
    }
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Request {
    pub id: RequestId,
    pub method: String,
    #[serde(default = "serde_json::Value::default")]
    #[serde(skip_serializing_if = "serde_json::Value::is_null")]
    pub params: serde_json::Value,
}

    pub(crate) fn send_request<R: lsp_types::request::Request>(
        &mut self,
        params: R::Params,
        handler: ReqHandler,
    ) {
        let request = self.req_queue.outgoing.register(R::METHOD.to_string(), params, handler);
        self.send(request.into());
    }

    fn send(&mut self, message: lsp_server::Message) {
        self.sender.send(message).unwrap()
    }

    fn handle_event(&mut self, event: Event) -> Result<()> {
        match event {
            Event::Lsp(msg) => match msg {
                lsp_server::Message::Request(req) => self.on_request(loop_start, req)?,
                lsp_server::Message::Notification(not) => {
                    self.on_notification(not)?;
                }
                lsp_server::Message::Response(resp) => self.complete_request(resp),
            },
            ...
        }
        ...
    }

impl GlobalState {
    fn run(mut self, inbox: Receiver<lsp_server::Message>) -> Result<()> {
        ...
        while let Some(event) = self.next_event(&inbox) {
            if let Event::Lsp(lsp_server::Message::Notification(not)) = &event {
                if not.method == lsp_types::notification::Exit::METHOD {
                    return Ok(());
                }
            }
            self.handle_event(event)?
        }
        ...
    }
}

const std = @import("std");
const expect = std.testing.expect;

const Payload = union {
    int: i32,
    float: f32,
    boolean: bool,
};

test "simple union" {
    var payload = Payload{ .int = 1234 };
    expect(payload.int == 1234);

    // 再割り当て
    payload = Payload{ .float = 12.34 };
    expect(payload.float == 12.34);
}

const std = @import("std");
const expect = std.testing.expect;

const E = enum {
    one,
    two,
    three,
};

const U = union(E) {
    one: i32,
    two: f32,
    three,
};

test "coercion between unions and enums" {
    var u: U = U{ .two = 12.34 };
    // e の型が E だから、型強制が発生して u が E.two になる？
    var e: E = u;
    except(e == E.two);

    const three: E = E.three;
    // another_u の型が U だから、型強制が発生して three が U.three になる？
    var another_u: U = three;
    expect(another_u == E.three);
}

/// Id of a request
pub const RequestId = union(enum) {
    String: []const u8,
    Integer: i64,
    Float: f64,
};

fn respondGeneric(id: types.RequestId, response: []const u8) !void {
    const id_len = switch (id) {
        .Integer => |id_val| blk: {
            if (id_val == 0) break :blk 1;
            var digits: usize = 1;
            var value = @divTrunc(id_val, 10);
            while (value != 0) : (value = @divTrunc(value, 10)) {
                digits += 1;
            }
            break :blk digits;
        },
        .String => |str_val| str_val.len + 2,
        else => unreachable,
    };
    ...
}