@enjoys/context-engine 1.0.0 → 1.0.1

package/data/completion/rust.json

@@ -0,0 +1,698 @@
+{
+  "language": "rust",
+  "completions": [
+    {
+      "label": "println!",
+      "kind": 1,
+      "detail": "Print to stdout with newline",
+      "documentation": { "value": "Prints to standard output with a newline.\n\n```rust\nprintln!(\"Hello, world!\");\nprintln!(\"x = {}\", x);\nprintln!(\"{name} is {age}\", name=\"Alice\", age=30);\n```" },
+      "insertText": "println!(\"${1:format}\", ${2:args});",
+      "insertTextRules": 4,
+      "sortText": "00_println"
+    },
+    {
+      "label": "eprintln!",
+      "kind": 1,
+      "detail": "Print to stderr with newline",
+      "documentation": { "value": "Prints to standard error with a newline.\n\n```rust\neprintln!(\"Error: {}\", msg);\neprintln!(\"Warning: file not found\");\n```" },
+      "insertText": "eprintln!(\"${1:format}\", ${2:args});",
+      "insertTextRules": 4,
+      "sortText": "00_eprintln"
+    },
+    {
+      "label": "format!",
+      "kind": 1,
+      "detail": "Create a formatted String",
+      "documentation": { "value": "Creates a `String` using interpolation of runtime expressions.\n\n```rust\nlet s = format!(\"Hello, {}!\", name);\nlet msg = format!(\"{} items found\", count);\nlet addr = format!(\"{}:{}\", host, port);\n```" },
+      "insertText": "format!(\"${1:format}\", ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "00_format"
+    },
+    {
+      "label": "vec!",
+      "kind": 1,
+      "detail": "Create a Vec from literal values",
+      "documentation": { "value": "Creates a `Vec` containing the arguments.\n\n```rust\nlet v = vec![1, 2, 3];\nlet zeros = vec![0; 10];\nlet names = vec![\"Alice\", \"Bob\"];\n```" },
+      "insertText": "vec![${1:elements}]",
+      "insertTextRules": 4,
+      "sortText": "00_vec"
+    },
+    {
+      "label": "panic!",
+      "kind": 1,
+      "detail": "Panic with a message",
+      "documentation": { "value": "Panics the current thread with the given message.\n\n```rust\npanic!(\"something went wrong\");\npanic!(\"index out of bounds: {}\", index);\n```" },
+      "insertText": "panic!(\"${1:message}\");",
+      "insertTextRules": 4,
+      "sortText": "00_panic"
+    },
+    {
+      "label": "assert!",
+      "kind": 1,
+      "detail": "Assert a boolean condition",
+      "documentation": { "value": "Panics if the given expression is false.\n\n```rust\nassert!(x > 0);\nassert!(result.is_ok(), \"Expected Ok, got {:?}\", result);\n```" },
+      "insertText": "assert!(${1:condition});",
+      "insertTextRules": 4,
+      "sortText": "00_assert"
+    },
+    {
+      "label": "assert_eq!",
+      "kind": 1,
+      "detail": "Assert two values are equal",
+      "documentation": { "value": "Panics if the two expressions are not equal.\n\n```rust\nassert_eq!(a, b);\nassert_eq!(result, 42, \"Expected 42\");\n```" },
+      "insertText": "assert_eq!(${1:left}, ${2:right});",
+      "insertTextRules": 4,
+      "sortText": "00_assert_eq"
+    },
+    {
+      "label": "assert_ne!",
+      "kind": 1,
+      "detail": "Assert two values are not equal",
+      "documentation": { "value": "Panics if the two expressions are equal.\n\n```rust\nassert_ne!(a, b);\nassert_ne!(result, 0, \"Should not be zero\");\n```" },
+      "insertText": "assert_ne!(${1:left}, ${2:right});",
+      "insertTextRules": 4,
+      "sortText": "00_assert_ne"
+    },
+    {
+      "label": "todo!",
+      "kind": 1,
+      "detail": "Mark unfinished code",
+      "documentation": { "value": "Indicates unfinished code. Panics with a \"not yet implemented\" message.\n\n```rust\nfn process() -> Result<()> {\n    todo!()\n}\nfn handle(event: Event) {\n    todo!(\"handle {:?}\", event)\n}\n```" },
+      "insertText": "todo!(\"${1:reason}\")",
+      "insertTextRules": 4,
+      "sortText": "00_todo"
+    },
+    {
+      "label": "unimplemented!",
+      "kind": 1,
+      "detail": "Mark unimplemented code",
+      "documentation": { "value": "Indicates unimplemented code by panicking.\n\n```rust\nfn serialize(&self) -> Vec<u8> {\n    unimplemented!()\n}\n```" },
+      "insertText": "unimplemented!()",
+      "insertTextRules": 4,
+      "sortText": "00_unimplemented"
+    },
+    {
+      "label": "dbg!",
+      "kind": 1,
+      "detail": "Debug print and return value",
+      "documentation": { "value": "Prints the value to stderr with file and line info and returns it.\n\n```rust\nlet x = dbg!(2 + 3);\ndbg!(&my_vec);\n```" },
+      "insertText": "dbg!(${1:expr})",
+      "insertTextRules": 4,
+      "sortText": "00_dbg"
+    },
+    {
+      "label": "write!",
+      "kind": 1,
+      "detail": "Write formatted data into a buffer",
+      "documentation": { "value": "Writes formatted data into a buffer implementing `std::fmt::Write` or `std::io::Write`.\n\n```rust\nuse std::fmt::Write;\nlet mut buf = String::new();\nwrite!(buf, \"Hello, {}!\", name)?;\n```" },
+      "insertText": "write!(${1:buf}, \"${2:format}\", ${3:args})",
+      "insertTextRules": 4,
+      "sortText": "00_write"
+    },
+    {
+      "label": "writeln!",
+      "kind": 1,
+      "detail": "Write formatted data with newline",
+      "documentation": { "value": "Same as `write!` but appends a newline.\n\n```rust\nwriteln!(buf, \"line: {}\", i)?;\nwriteln!(f, \"{}: {}\", key, value)?;\n```" },
+      "insertText": "writeln!(${1:buf}, \"${2:format}\", ${3:args})",
+      "insertTextRules": 4,
+      "sortText": "00_writeln"
+    },
+    {
+      "label": "include_str!",
+      "kind": 1,
+      "detail": "Include a file as a string",
+      "documentation": { "value": "Includes a UTF-8 encoded file as a string at compile time.\n\n```rust\nlet contents = include_str!(\"data.txt\");\nlet sql = include_str!(\"../migrations/001.sql\");\n```" },
+      "insertText": "include_str!(\"${1:path}\")",
+      "insertTextRules": 4,
+      "sortText": "00_include_str"
+    },
+    {
+      "label": "include_bytes!",
+      "kind": 1,
+      "detail": "Include a file as bytes",
+      "documentation": { "value": "Includes a file as a byte array at compile time.\n\n```rust\nlet data = include_bytes!(\"image.png\");\nlet cert = include_bytes!(\"cert.pem\");\n```" },
+      "insertText": "include_bytes!(\"${1:path}\")",
+      "insertTextRules": 4,
+      "sortText": "00_include_bytes"
+    },
+    {
+      "label": "concat!",
+      "kind": 1,
+      "detail": "Concatenate literals into a static string",
+      "documentation": { "value": "Concatenates literals into a `&'static str`.\n\n```rust\nlet s = concat!(\"Hello\", \", \", \"world!\");\nlet version = concat!(\"v\", env!(\"CARGO_PKG_VERSION\"));\n```" },
+      "insertText": "concat!(${1:literals})",
+      "insertTextRules": 4,
+      "sortText": "00_concat"
+    },
+    {
+      "label": "cfg!",
+      "kind": 1,
+      "detail": "Evaluate configuration flags at compile time",
+      "documentation": { "value": "Evaluates configuration flags at compile time and returns a bool.\n\n```rust\nif cfg!(target_os = \"linux\") {\n    println!(\"Running on Linux\");\n}\nif cfg!(debug_assertions) {\n    println!(\"Debug mode\");\n}\n```" },
+      "insertText": "cfg!(${1:flag})",
+      "insertTextRules": 4,
+      "sortText": "00_cfg"
+    },
+    {
+      "label": "env!",
+      "kind": 1,
+      "detail": "Read environment variable at compile time",
+      "documentation": { "value": "Inspects an environment variable at compile time.\n\n```rust\nlet version = env!(\"CARGO_PKG_VERSION\");\nlet name = env!(\"CARGO_PKG_NAME\");\n```" },
+      "insertText": "env!(\"${1:VAR}\")",
+      "insertTextRules": 4,
+      "sortText": "00_env"
+    },
+    {
+      "label": "matches!",
+      "kind": 1,
+      "detail": "Check if expression matches a pattern",
+      "documentation": { "value": "Returns a bool indicating whether an expression matches any of the given patterns.\n\n```rust\nlet is_vowel = matches!(c, 'a' | 'e' | 'i' | 'o' | 'u');\nlet is_some = matches!(opt, Some(_));\n```" },
+      "insertText": "matches!(${1:expr}, ${2:pattern})",
+      "insertTextRules": 4,
+      "sortText": "00_matches"
+    },
+    {
+      "label": "compile_error!",
+      "kind": 1,
+      "detail": "Emit a compile-time error",
+      "documentation": { "value": "Causes compilation to fail with the given error message.\n\n```rust\n#[cfg(not(any(feature = \"a\", feature = \"b\")))]\ncompile_error!(\"Either feature 'a' or 'b' must be enabled\");\n```" },
+      "insertText": "compile_error!(\"${1:message}\");",
+      "insertTextRules": 4,
+      "sortText": "00_compile_error"
+    },
+    {
+      "label": "fn",
+      "kind": 14,
+      "detail": "Function definition",
+      "documentation": { "value": "Defines a function.\n\n```rust\nfn add(a: i32, b: i32) -> i32 {\n    a + b\n}\nfn greet(name: &str) {\n    println!(\"Hello, {}!\", name);\n}\n```" },
+      "insertText": "fn ${1:name}(${2:params}) -> ${3:ReturnType} {\n    ${4:body}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_fn"
+    },
+    {
+      "label": "let",
+      "kind": 14,
+      "detail": "Variable binding (immutable)",
+      "documentation": { "value": "Creates an immutable variable binding.\n\n```rust\nlet x = 5;\nlet name: String = String::from(\"Alice\");\nlet (a, b) = (1, 2);\n```" },
+      "insertText": "let ${1:name} = ${2:value};",
+      "insertTextRules": 4,
+      "sortText": "01_let"
+    },
+    {
+      "label": "let mut",
+      "kind": 14,
+      "detail": "Mutable variable binding",
+      "documentation": { "value": "Creates a mutable variable binding.\n\n```rust\nlet mut count = 0;\ncount += 1;\nlet mut buf = Vec::new();\n```" },
+      "insertText": "let mut ${1:name} = ${2:value};",
+      "insertTextRules": 4,
+      "sortText": "01_let_mut"
+    },
+    {
+      "label": "struct",
+      "kind": 14,
+      "detail": "Struct definition",
+      "documentation": { "value": "Defines a struct type.\n\n```rust\nstruct Point {\n    x: f64,\n    y: f64,\n}\nstruct Color(u8, u8, u8); // tuple struct\nstruct Unit; // unit struct\n```" },
+      "insertText": "struct ${1:Name} {\n    ${2:field}: ${3:Type},\n}",
+      "insertTextRules": 4,
+      "sortText": "01_struct"
+    },
+    {
+      "label": "enum",
+      "kind": 14,
+      "detail": "Enum definition",
+      "documentation": { "value": "Defines an enum type.\n\n```rust\nenum Direction {\n    Up,\n    Down,\n    Left,\n    Right,\n}\nenum Message {\n    Quit,\n    Text(String),\n    Move { x: i32, y: i32 },\n}\n```" },
+      "insertText": "enum ${1:Name} {\n    ${2:Variant},\n}",
+      "insertTextRules": 4,
+      "sortText": "01_enum"
+    },
+    {
+      "label": "impl",
+      "kind": 14,
+      "detail": "Implementation block",
+      "documentation": { "value": "Defines methods and associated functions for a type.\n\n```rust\nimpl Point {\n    fn new(x: f64, y: f64) -> Self {\n        Self { x, y }\n    }\n    fn distance(&self, other: &Point) -> f64 {\n        ((self.x - other.x).powi(2) + (self.y - other.y).powi(2)).sqrt()\n    }\n}\n```" },
+      "insertText": "impl ${1:Type} {\n    ${2:methods}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_impl"
+    },
+    {
+      "label": "trait",
+      "kind": 14,
+      "detail": "Trait definition",
+      "documentation": { "value": "Defines a trait (interface).\n\n```rust\ntrait Summary {\n    fn summarize(&self) -> String;\n    fn headline(&self) -> String {\n        String::from(\"(Read more...)\")\n    }\n}\n```" },
+      "insertText": "trait ${1:Name} {\n    fn ${2:method}(&self) -> ${3:ReturnType};\n}",
+      "insertTextRules": 4,
+      "sortText": "01_trait"
+    },
+    {
+      "label": "pub",
+      "kind": 14,
+      "detail": "Public visibility modifier",
+      "documentation": { "value": "Makes an item accessible from outside the current module.\n\n```rust\npub fn public_function() {}\npub struct PublicStruct { pub field: i32 }\npub(crate) fn crate_only() {}\npub(super) fn parent_only() {}\n```" },
+      "insertText": "pub ",
+      "insertTextRules": 4,
+      "sortText": "01_pub"
+    },
+    {
+      "label": "mod",
+      "kind": 14,
+      "detail": "Module declaration",
+      "documentation": { "value": "Declares a module.\n\n```rust\nmod utils;\nmod tests {\n    use super::*;\n    #[test]\n    fn test_add() {\n        assert_eq!(add(2, 3), 5);\n    }\n}\n```" },
+      "insertText": "mod ${1:name} {\n    ${2:body}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_mod"
+    },
+    {
+      "label": "use",
+      "kind": 14,
+      "detail": "Use declaration / import",
+      "documentation": { "value": "Brings items into scope.\n\n```rust\nuse std::collections::HashMap;\nuse std::io::{self, Read, Write};\nuse crate::models::User;\n```" },
+      "insertText": "use ${1:path};",
+      "insertTextRules": 4,
+      "sortText": "01_use"
+    },
+    {
+      "label": "match",
+      "kind": 14,
+      "detail": "Match expression",
+      "documentation": { "value": "Pattern matching on a value.\n\n```rust\nmatch value {\n    0 => println!(\"zero\"),\n    1..=9 => println!(\"single digit\"),\n    _ => println!(\"other\"),\n}\nmatch result {\n    Ok(val) => val,\n    Err(e) => return Err(e),\n}\n```" },
+      "insertText": "match ${1:expr} {\n    ${2:pattern} => ${3:result},\n    _ => ${4:default},\n}",
+      "insertTextRules": 4,
+      "sortText": "01_match"
+    },
+    {
+      "label": "if let",
+      "kind": 14,
+      "detail": "Conditional pattern match",
+      "documentation": { "value": "Combines `if` with pattern matching.\n\n```rust\nif let Some(val) = optional {\n    println!(\"Got: {}\", val);\n}\nif let Ok(n) = \"42\".parse::<i32>() {\n    println!(\"parsed: {}\", n);\n}\n```" },
+      "insertText": "if let ${1:Some(val)} = ${2:expr} {\n    ${3:body}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_if_let"
+    },
+    {
+      "label": "while let",
+      "kind": 14,
+      "detail": "Loop with pattern match",
+      "documentation": { "value": "Loops while a pattern matches.\n\n```rust\nwhile let Some(item) = stack.pop() {\n    process(item);\n}\nwhile let Ok(line) = reader.read_line(&mut buf) {\n    println!(\"{}\", line);\n}\n```" },
+      "insertText": "while let ${1:Some(val)} = ${2:expr} {\n    ${3:body}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_while_let"
+    },
+    {
+      "label": "loop",
+      "kind": 14,
+      "detail": "Infinite loop",
+      "documentation": { "value": "Creates an infinite loop. Use `break` to exit.\n\n```rust\nloop {\n    let input = read_input();\n    if input == \"quit\" {\n        break;\n    }\n    process(input);\n}\nlet result = loop {\n    if done() { break 42; }\n};\n```" },
+      "insertText": "loop {\n    ${1:body}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_loop"
+    },
+    {
+      "label": "for..in",
+      "kind": 14,
+      "detail": "For loop over iterator",
+      "documentation": { "value": "Iterates over an iterator.\n\n```rust\nfor item in &vec {\n    println!(\"{}\", item);\n}\nfor i in 0..10 {\n    println!(\"{}\", i);\n}\nfor (i, val) in vec.iter().enumerate() {\n    println!(\"{}: {}\", i, val);\n}\n```" },
+      "insertText": "for ${1:item} in ${2:iter} {\n    ${3:body}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_for_in"
+    },
+    {
+      "label": "async fn",
+      "kind": 14,
+      "detail": "Async function definition",
+      "documentation": { "value": "Defines an async function that returns a `Future`.\n\n```rust\nasync fn fetch(url: &str) -> Result<String, Error> {\n    let resp = reqwest::get(url).await?;\n    resp.text().await\n}\n```" },
+      "insertText": "async fn ${1:name}(${2:params}) -> ${3:ReturnType} {\n    ${4:body}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_async_fn"
+    },
+    {
+      "label": ".await",
+      "kind": 14,
+      "detail": "Await a future",
+      "documentation": { "value": "Suspends execution until the future is ready.\n\n```rust\nlet result = some_async_fn().await;\nlet body = response.text().await?;\n```" },
+      "insertText": ".await",
+      "insertTextRules": 4,
+      "sortText": "01_await"
+    },
+    {
+      "label": "return",
+      "kind": 14,
+      "detail": "Return from function",
+      "documentation": { "value": "Returns a value from the current function.\n\n```rust\nfn check(x: i32) -> bool {\n    if x < 0 { return false; }\n    true\n}\n```" },
+      "insertText": "return ${1:value};",
+      "insertTextRules": 4,
+      "sortText": "01_return"
+    },
+    {
+      "label": "type",
+      "kind": 14,
+      "detail": "Type alias",
+      "documentation": { "value": "Creates a type alias.\n\n```rust\ntype Result<T> = std::result::Result<T, MyError>;\ntype Callback = Box<dyn Fn(i32) -> i32>;\n```" },
+      "insertText": "type ${1:Name} = ${2:Type};",
+      "insertTextRules": 4,
+      "sortText": "01_type"
+    },
+    {
+      "label": "where",
+      "kind": 14,
+      "detail": "Where clause for generics",
+      "documentation": { "value": "Specifies trait bounds in a where clause.\n\n```rust\nfn process<T>(item: T) -> String\nwhere\n    T: Display + Clone,\n{\n    format!(\"{}\", item)\n}\n```" },
+      "insertText": "where\n    ${1:T}: ${2:Trait},",
+      "insertTextRules": 4,
+      "sortText": "01_where"
+    },
+    {
+      "label": "const",
+      "kind": 14,
+      "detail": "Compile-time constant",
+      "documentation": { "value": "Declares a compile-time constant.\n\n```rust\nconst MAX_SIZE: usize = 1024;\nconst PI: f64 = 3.14159265358979;\n```" },
+      "insertText": "const ${1:NAME}: ${2:Type} = ${3:value};",
+      "insertTextRules": 4,
+      "sortText": "01_const"
+    },
+    {
+      "label": "static",
+      "kind": 14,
+      "detail": "Static variable",
+      "documentation": { "value": "Declares a static variable with a `'static` lifetime.\n\n```rust\nstatic COUNTER: AtomicUsize = AtomicUsize::new(0);\nstatic CONFIG: &str = \"default\";\n```" },
+      "insertText": "static ${1:NAME}: ${2:Type} = ${3:value};",
+      "insertTextRules": 4,
+      "sortText": "01_static"
+    },
+    {
+      "label": "unsafe",
+      "kind": 14,
+      "detail": "Unsafe block",
+      "documentation": { "value": "Marks a block or function as unsafe, allowing raw pointer dereferences and other unsafe operations.\n\n```rust\nunsafe {\n    let val = *raw_ptr;\n}\nunsafe fn dangerous() { }\n```" },
+      "insertText": "unsafe {\n    ${1:body}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_unsafe"
+    },
+    {
+      "label": "extern",
+      "kind": 14,
+      "detail": "Extern block for FFI",
+      "documentation": { "value": "Declares an external function interface.\n\n```rust\nextern \"C\" {\n    fn abs(input: i32) -> i32;\n}\n```" },
+      "insertText": "extern \"C\" {\n    fn ${1:name}(${2:params}) -> ${3:ReturnType};\n}",
+      "insertTextRules": 4,
+      "sortText": "01_extern"
+    },
+    {
+      "label": "ref",
+      "kind": 14,
+      "detail": "Bind by reference in patterns",
+      "documentation": { "value": "Binds by reference during pattern matching.\n\n```rust\nlet ref x = 5; // x: &i32\nmatch value {\n    ref v => println!(\"{}\", v),\n}\n```" },
+      "insertText": "ref ${1:name}",
+      "insertTextRules": 4,
+      "sortText": "01_ref"
+    },
+    {
+      "label": "dyn",
+      "kind": 14,
+      "detail": "Dynamic dispatch trait object",
+      "documentation": { "value": "Specifies a trait object type with dynamic dispatch.\n\n```rust\nfn log(writer: &dyn Write) { }\nlet handler: Box<dyn Fn()> = Box::new(|| println!(\"hi\"));\n```" },
+      "insertText": "dyn ${1:Trait}",
+      "insertTextRules": 4,
+      "sortText": "01_dyn"
+    },
+    {
+      "label": "Box::new",
+      "kind": 1,
+      "detail": "Allocate value on the heap",
+      "documentation": { "value": "Allocates memory on the heap and places the value into it.\n\n```rust\nlet b = Box::new(5);\nlet s = Box::new(String::from(\"hello\"));\nlet trait_obj: Box<dyn Display> = Box::new(42);\n```" },
+      "insertText": "Box::new(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_box_new"
+    },
+    {
+      "label": "String::new",
+      "kind": 1,
+      "detail": "Create an empty String",
+      "documentation": { "value": "Creates a new empty `String`.\n\n```rust\nlet mut s = String::new();\ns.push_str(\"hello\");\n```" },
+      "insertText": "String::new()",
+      "insertTextRules": 4,
+      "sortText": "02_string_new"
+    },
+    {
+      "label": "String::from",
+      "kind": 1,
+      "detail": "Create a String from a &str",
+      "documentation": { "value": "Converts a `&str` into a `String`.\n\n```rust\nlet s = String::from(\"hello\");\nlet greeting = String::from(\"Hello, world!\");\n```" },
+      "insertText": "String::from(\"${1:text}\")",
+      "insertTextRules": 4,
+      "sortText": "02_string_from"
+    },
+    {
+      "label": "Vec::new",
+      "kind": 1,
+      "detail": "Create an empty Vec",
+      "documentation": { "value": "Constructs a new, empty `Vec<T>`.\n\n```rust\nlet mut v: Vec<i32> = Vec::new();\nv.push(1);\n```" },
+      "insertText": "Vec::new()",
+      "insertTextRules": 4,
+      "sortText": "02_vec_new"
+    },
+    {
+      "label": "Vec::with_capacity",
+      "kind": 1,
+      "detail": "Create a Vec with preallocated capacity",
+      "documentation": { "value": "Constructs a new, empty `Vec<T>` with the specified capacity.\n\n```rust\nlet mut v = Vec::with_capacity(100);\nv.push(42);\nassert!(v.capacity() >= 100);\n```" },
+      "insertText": "Vec::with_capacity(${1:capacity})",
+      "insertTextRules": 4,
+      "sortText": "02_vec_with_capacity"
+    },
+    {
+      "label": "HashMap::new",
+      "kind": 1,
+      "detail": "Create an empty HashMap",
+      "documentation": { "value": "Creates an empty `HashMap`.\n\n```rust\nuse std::collections::HashMap;\nlet mut map = HashMap::new();\nmap.insert(\"key\", \"value\");\n```" },
+      "insertText": "HashMap::new()",
+      "insertTextRules": 4,
+      "sortText": "02_hashmap_new"
+    },
+    {
+      "label": "HashSet::new",
+      "kind": 1,
+      "detail": "Create an empty HashSet",
+      "documentation": { "value": "Creates an empty `HashSet`.\n\n```rust\nuse std::collections::HashSet;\nlet mut set = HashSet::new();\nset.insert(42);\n```" },
+      "insertText": "HashSet::new()",
+      "insertTextRules": 4,
+      "sortText": "02_hashset_new"
+    },
+    {
+      "label": "BTreeMap::new",
+      "kind": 1,
+      "detail": "Create an empty BTreeMap",
+      "documentation": { "value": "Creates an empty `BTreeMap` (sorted map).\n\n```rust\nuse std::collections::BTreeMap;\nlet mut map = BTreeMap::new();\nmap.insert(1, \"one\");\n```" },
+      "insertText": "BTreeMap::new()",
+      "insertTextRules": 4,
+      "sortText": "02_btreemap_new"
+    },
+    {
+      "label": "Option::Some",
+      "kind": 1,
+      "detail": "Wrap a value in Some",
+      "documentation": { "value": "Creates an `Option` containing a value.\n\n```rust\nlet x: Option<i32> = Some(42);\nlet name = Some(String::from(\"Alice\"));\n```" },
+      "insertText": "Some(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_option_some"
+    },
+    {
+      "label": "Option::None",
+      "kind": 1,
+      "detail": "No value",
+      "documentation": { "value": "Represents the absence of a value.\n\n```rust\nlet x: Option<i32> = None;\nfn find(id: u32) -> Option<&User> { None }\n```" },
+      "insertText": "None",
+      "insertTextRules": 4,
+      "sortText": "02_option_none"
+    },
+    {
+      "label": "Result::Ok",
+      "kind": 1,
+      "detail": "Success result",
+      "documentation": { "value": "Contains the success value.\n\n```rust\nlet r: Result<i32, String> = Ok(42);\nfn parse(s: &str) -> Result<i32, ParseIntError> { Ok(0) }\n```" },
+      "insertText": "Ok(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_result_ok"
+    },
+    {
+      "label": "Result::Err",
+      "kind": 1,
+      "detail": "Error result",
+      "documentation": { "value": "Contains the error value.\n\n```rust\nlet r: Result<i32, String> = Err(\"failed\".into());\nreturn Err(MyError::NotFound);\n```" },
+      "insertText": "Err(${1:error})",
+      "insertTextRules": 4,
+      "sortText": "02_result_err"
+    },
+    {
+      "label": "Rc::new",
+      "kind": 1,
+      "detail": "Create a new reference-counted pointer",
+      "documentation": { "value": "Constructs a new `Rc<T>` (single-threaded reference counting).\n\n```rust\nuse std::rc::Rc;\nlet shared = Rc::new(vec![1, 2, 3]);\nlet clone = Rc::clone(&shared);\n```" },
+      "insertText": "Rc::new(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_rc_new"
+    },
+    {
+      "label": "Arc::new",
+      "kind": 1,
+      "detail": "Create a new atomic reference-counted pointer",
+      "documentation": { "value": "Constructs a new `Arc<T>` (thread-safe reference counting).\n\n```rust\nuse std::sync::Arc;\nlet shared = Arc::new(data);\nlet clone = Arc::clone(&shared);\n```" },
+      "insertText": "Arc::new(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_arc_new"
+    },
+    {
+      "label": "Mutex::new",
+      "kind": 1,
+      "detail": "Create a new mutex",
+      "documentation": { "value": "Creates a new `Mutex<T>`.\n\n```rust\nuse std::sync::Mutex;\nlet m = Mutex::new(0);\nlet mut val = m.lock().unwrap();\n*val += 1;\n```" },
+      "insertText": "Mutex::new(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_mutex_new"
+    },
+    {
+      "label": "Cell::new",
+      "kind": 1,
+      "detail": "Create a new Cell",
+      "documentation": { "value": "Creates a new `Cell<T>` for interior mutability of `Copy` types.\n\n```rust\nuse std::cell::Cell;\nlet c = Cell::new(5);\nc.set(10);\nassert_eq!(c.get(), 10);\n```" },
+      "insertText": "Cell::new(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_cell_new"
+    },
+    {
+      "label": "RefCell::new",
+      "kind": 1,
+      "detail": "Create a new RefCell",
+      "documentation": { "value": "Creates a new `RefCell<T>` for interior mutability with runtime borrow checking.\n\n```rust\nuse std::cell::RefCell;\nlet c = RefCell::new(vec![1, 2, 3]);\nc.borrow_mut().push(4);\n```" },
+      "insertText": "RefCell::new(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_refcell_new"
+    },
+    {
+      "label": "#[derive(...)]",
+      "kind": 14,
+      "detail": "Derive trait implementations",
+      "documentation": { "value": "Automatically implements traits for a type.\n\n```rust\n#[derive(Debug, Clone, PartialEq)]\nstruct Point { x: f64, y: f64 }\n\n#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]\nenum Color { Red, Green, Blue }\n\n#[derive(Default, serde::Serialize, serde::Deserialize)]\nstruct Config { port: u16, host: String }\n```" },
+      "insertText": "#[derive(${1:Debug, Clone, PartialEq})]",
+      "insertTextRules": 4,
+      "sortText": "03_derive"
+    },
+    {
+      "label": "impl Trait for Type",
+      "kind": 14,
+      "detail": "Implement a trait for a type",
+      "documentation": { "value": "Implements a trait for a specific type.\n\n```rust\nimpl Display for Point {\n    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n        write!(f, \"({}, {})\", self.x, self.y)\n    }\n}\nimpl From<&str> for MyType {\n    fn from(s: &str) -> Self { MyType(s.to_string()) }\n}\n```" },
+      "insertText": "impl ${1:Trait} for ${2:Type} {\n    ${3:methods}\n}",
+      "insertTextRules": 4,
+      "sortText": "03_impl_trait"
+    },
+    {
+      "label": "match arms",
+      "kind": 14,
+      "detail": "Match with multiple arms",
+      "documentation": { "value": "Pattern matching with multiple arms.\n\n```rust\nmatch command {\n    Command::Quit => break,\n    Command::Echo(msg) => println!(\"{}\", msg),\n    Command::Move { x, y } => move_to(x, y),\n    _ => eprintln!(\"Unknown command\"),\n}\n```" },
+      "insertText": "match ${1:expr} {\n    ${2:Pattern1} => ${3:expr1},\n    ${4:Pattern2} => ${5:expr2},\n    _ => ${6:default},\n}",
+      "insertTextRules": 4,
+      "sortText": "03_match_arms"
+    },
+    {
+      "label": "? (error propagation)",
+      "kind": 14,
+      "detail": "Propagate errors with ?",
+      "documentation": { "value": "The `?` operator propagates errors. If the value is `Err`, it returns early.\n\n```rust\nfn read_config(path: &str) -> Result<Config, Box<dyn Error>> {\n    let contents = std::fs::read_to_string(path)?;\n    let config: Config = serde_json::from_str(&contents)?;\n    Ok(config)\n}\n```" },
+      "insertText": "${1:expr}?",
+      "insertTextRules": 4,
+      "sortText": "03_question_mark"
+    },
+    {
+      "label": "closure",
+      "kind": 14,
+      "detail": "Closure (anonymous function)",
+      "documentation": { "value": "Creates a closure.\n\n```rust\nlet add = |a, b| a + b;\nlet double = |x: i32| -> i32 { x * 2 };\nvec.iter().filter(|x| **x > 5).collect::<Vec<_>>();\nvec.sort_by(|a, b| a.cmp(b));\n```" },
+      "insertText": "|${1:params}| ${2:body}",
+      "insertTextRules": 4,
+      "sortText": "03_closure"
+    },
+    {
+      "label": "async/await",
+      "kind": 14,
+      "detail": "Async block with await",
+      "documentation": { "value": "Creates an async block.\n\n```rust\nlet future = async {\n    let data = fetch(\"http://example.com\").await?;\n    process(data).await\n};\n```" },
+      "insertText": "async {\n    let ${1:result} = ${2:future}.await${3:?};\n    ${4:body}\n}",
+      "insertTextRules": 4,
+      "sortText": "03_async_await"
+    },
+    {
+      "label": "lifetime annotation",
+      "kind": 14,
+      "detail": "Lifetime annotation",
+      "documentation": { "value": "Annotates lifetimes to help the borrow checker.\n\n```rust\nfn longest<'a>(x: &'a str, y: &'a str) -> &'a str {\n    if x.len() > y.len() { x } else { y }\n}\nstruct Excerpt<'a> {\n    part: &'a str,\n}\n```" },
+      "insertText": "<'${1:a}>",
+      "insertTextRules": 4,
+      "sortText": "03_lifetime"
+    },
+    {
+      "label": "Display trait",
+      "kind": 8,
+      "detail": "Implement Display for custom formatting",
+      "documentation": { "value": "Format trait for the `{}` marker. Used by `println!`, `format!`, etc.\n\n```rust\nuse std::fmt;\nimpl fmt::Display for Point {\n    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n        write!(f, \"({}, {})\", self.x, self.y)\n    }\n}\n```" },
+      "insertText": "impl fmt::Display for ${1:Type} {\n    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n        write!(f, \"${2:format}\", ${3:self.field})\n    }\n}",
+      "insertTextRules": 4,
+      "sortText": "04_display"
+    },
+    {
+      "label": "Debug trait",
+      "kind": 8,
+      "detail": "Implement Debug for debug formatting",
+      "documentation": { "value": "Format trait for the `{:?}` marker. Usually derived.\n\n```rust\n#[derive(Debug)]\nstruct Point { x: f64, y: f64 }\nprintln!(\"{:?}\", point);\nprintln!(\"{:#?}\", point); // pretty-print\n```" },
+      "insertText": "#[derive(Debug)]",
+      "insertTextRules": 4,
+      "sortText": "04_debug"
+    },
+    {
+      "label": "Clone trait",
+      "kind": 8,
+      "detail": "Derive or implement Clone",
+      "documentation": { "value": "A trait for explicitly duplicating a value.\n\n```rust\n#[derive(Clone)]\nstruct Config { name: String, port: u16 }\nlet copy = config.clone();\n```" },
+      "insertText": "#[derive(Clone)]",
+      "insertTextRules": 4,
+      "sortText": "04_clone"
+    },
+    {
+      "label": "Default trait",
+      "kind": 8,
+      "detail": "Derive or implement Default",
+      "documentation": { "value": "A trait for creating a default value.\n\n```rust\n#[derive(Default)]\nstruct Config { port: u16, debug: bool }\nlet cfg = Config::default();\nlet cfg = Config { port: 8080, ..Default::default() };\n```" },
+      "insertText": "#[derive(Default)]",
+      "insertTextRules": 4,
+      "sortText": "04_default"
+    },
+    {
+      "label": "Iterator trait",
+      "kind": 8,
+      "detail": "Implement Iterator",
+      "documentation": { "value": "A trait for dealing with iterators.\n\n```rust\nimpl Iterator for Counter {\n    type Item = u32;\n    fn next(&mut self) -> Option<Self::Item> {\n        if self.count < 5 {\n            self.count += 1;\n            Some(self.count)\n        } else {\n            None\n        }\n    }\n}\n```" },
+      "insertText": "impl Iterator for ${1:Type} {\n    type Item = ${2:ItemType};\n    fn next(&mut self) -> Option<Self::Item> {\n        ${3:body}\n    }\n}",
+      "insertTextRules": 4,
+      "sortText": "04_iterator"
+    },
+    {
+      "label": "From trait",
+      "kind": 8,
+      "detail": "Implement From for type conversion",
+      "documentation": { "value": "Used for value-to-value conversion. Implementing `From` automatically provides `Into`.\n\n```rust\nimpl From<&str> for MyString {\n    fn from(s: &str) -> Self {\n        MyString(s.to_string())\n    }\n}\nlet s: MyString = \"hello\".into();\n```" },
+      "insertText": "impl From<${1:SourceType}> for ${2:TargetType} {\n    fn from(${3:val}: ${1:SourceType}) -> Self {\n        ${4:body}\n    }\n}",
+      "insertTextRules": 4,
+      "sortText": "04_from"
+    },
+    {
+      "label": "Drop trait",
+      "kind": 8,
+      "detail": "Implement Drop for cleanup",
+      "documentation": { "value": "Custom code to run when a value goes out of scope.\n\n```rust\nimpl Drop for TempFile {\n    fn drop(&mut self) {\n        std::fs::remove_file(&self.path).ok();\n    }\n}\n```" },
+      "insertText": "impl Drop for ${1:Type} {\n    fn drop(&mut self) {\n        ${2:cleanup}\n    }\n}",
+      "insertTextRules": 4,
+      "sortText": "04_drop"
+    }
+  ]
+}