818e0d0 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

818e0d0 — Peter John 2026-11-02T19:44:08+05:30

T7: editor support

Files changed (2) hide show

plum-lsp/src/completion.rs +55 -13
plum-lsp/src/main.rs +272 -1

plum-lsp/src/completion.rs CHANGED Viewed

@@ -341,21 +341,15 @@ fn walkStmt(
     }
 }
-/// Completion items for `receiver`'s methods/fields, given the function the
+/// Best-effort type of `receiver` (`self`, an int literal, or a local) inside `cursor_fn`.
-/// cursor is inside (`None` if the cursor isn't inside any function — e.g. a
-/// top-level `test` body isn't covered, see this module's doc comment).
-pub fn memberItems(
+pub fn receiverType(
     cursor_fn: Option<&ast::Fn>,
     receiver: &str,
     global_env: &TypeEnv,
     ctx: &CheckCtx,
-    stars: &[ast::Fn],
-) -> Vec<CompletionItem> {
+) -> Option<PlumType> {
-    let Some(f) = cursor_fn else {
+    let f = cursor_fn?;
-        return Vec::new();
-    };
-    let receiver_ty = if receiver == "self" {
+    if receiver == "self" {
         f.type_param.as_ref().map(|r| {
             plumTypeFromAst(&ast::Type {
                 name: r.clone(),
@@ -367,9 +361,57 @@ pub fn memberItems(
         Some(PlumType::TInt)
     } else {
         localVarTypes(f, global_env, ctx).get(receiver).cloned()
+    }
+}
+/// Fields and methods of trait `t` (no hidden `__get_`/`__set_` accessors).
+pub fn traitItems(t: &ast::TraitDecl) -> Vec<CompletionItem> {
+    let mut items: Vec<CompletionItem> = t
+        .fields
+        .iter()
+        .map(|f| CompletionItem {
+            label: f.name.clone(),
+            kind: Some(CompletionItemKind::FIELD),
+            detail: Some(typeText(&f.ty)),
+            ..Default::default()
+        })
+        .collect();
+    for m in t.methods.iter().chain(t.required.iter()) {
+        if m.has_self && !items.iter().any(|i| i.label == m.name) {
+            items.push(CompletionItem {
+                label: m.name.clone(),
+                kind: Some(CompletionItemKind::METHOD),
+                ..Default::default()
-    };
+            });
+        }
+    }
+    items
+}
+/// Source-like text of a type: `Name` or `Name[A, B]`.
+pub fn typeText(t: &ast::Type) -> String {
+    if t.generics.is_empty() {
+        t.name.clone()
+    } else {
+        format!(
+            "{}[{}]",
+            t.name,
+            t.generics.iter().map(typeText).collect::<Vec<_>>().join(", ")
+        )
+    }
+}
+/// Completion items for `receiver`'s methods/fields, given the function the
+/// cursor is inside (`None` if the cursor isn't inside any function — e.g. a
+/// top-level `test` body isn't covered, see this module's doc comment).
+pub fn memberItems(
+    cursor_fn: Option<&ast::Fn>,
+    receiver: &str,
+    global_env: &TypeEnv,
+    ctx: &CheckCtx,
+    stars: &[ast::Fn],
+) -> Vec<CompletionItem> {
-    let Some(ty) = receiver_ty else {
+    let Some(ty) = receiverType(cursor_fn, receiver, global_env, ctx) else {
         return Vec::new();
     };
     let Some(recv_name) = methodReceiverName(&ty) else {

plum-lsp/src/main.rs CHANGED Viewed

@@ -33,6 +33,8 @@ use tower_lsp::{Client, LanguageServer, LspService, Server};
 mod completion;
+use plum_core::ast;
 struct Backend {
     client: Client,
     docs: Mutex<HashMap<Url, String>>,
@@ -199,6 +201,8 @@ impl LanguageServer for Backend {
                     trigger_characters: Some(vec![".".to_string()]),
                     ..Default::default()
                 }),
+                hover_provider: Some(HoverProviderCapability::Simple(true)),
+                definition_provider: Some(OneOf::Left(true)),
                 ..Default::default()
             },
             server_info: Some(ServerInfo {
@@ -244,6 +248,45 @@ impl LanguageServer for Backend {
         self.docs.lock().await.remove(&params.text_document.uri);
     }
+    async fn hover(&self, params: HoverParams) -> RpcResult<Option<Hover>> {
+        let p = params.text_document_position_params;
+        let Ok(path) = p.text_document.uri.to_file_path() else {
+            return Ok(None);
+        };
+        let Some(text) = self.docs.lock().await.get(&p.text_document.uri).cloned() else {
+            return Ok(None);
+        };
+        Ok(hoverAt(&path, &self.libPath, &text, p.position.line as usize, p.position.character as usize)
+            .map(|s| Hover {
+                contents: HoverContents::Scalar(MarkedString::String(s)),
+                range: None,
+            }))
+    }
+    async fn goto_definition(
+        &self,
+        params: GotoDefinitionParams,
+    ) -> RpcResult<Option<GotoDefinitionResponse>> {
+        let p = params.text_document_position_params;
+        let Ok(path) = p.text_document.uri.to_file_path() else {
+            return Ok(None);
+        };
+        let Some(text) = self.docs.lock().await.get(&p.text_document.uri).cloned() else {
+            return Ok(None);
+        };
+        let Some((file, l, c)) = definitionAt(&path, &self.libPath, &text, p.position.line as usize, p.position.character as usize) else {
+            return Ok(None);
+        };
+        let Ok(uri) = Url::from_file_path(&file) else {
+            return Ok(None);
+        };
+        let pos = Position::new(l, c);
+        Ok(Some(GotoDefinitionResponse::Scalar(Location {
+            uri,
+            range: Range { start: pos, end: pos },
+        })))
+    }
     async fn completion(&self, params: CompletionParams) -> RpcResult<Option<CompletionResponse>> {
         let uri = params.text_document_position.text_document.uri;
         let pos = params.text_document_position.position;
@@ -328,7 +371,186 @@ fn memberCompletionFor(
         statics: Some(&statics),
     };
     let cursor_fn = completion::enclosingFn(&own_source, cursor_line);
+    if let Some(ty) = completion::receiverType(cursor_fn, receiver, &global_env, &ctx) {
+        if let Some(name) = plum_checker::methodReceiverName(&ty) {
+            if let Some(t) = merged.traits.iter().find(|t| t.name == name) {
+                return completion::traitItems(t);
+            }
+        }
+    }
+    let mut items =
-    completion::memberItems(cursor_fn, receiver, &global_env, &ctx, &merged.stars)
+        completion::memberItems(cursor_fn, receiver, &global_env, &ctx, &merged.stars);
+    items.retain(|i| !i.label.starts_with("__get_") && !i.label.starts_with("__set_"));
+    items
+}
+/// What the cursor is on, for hover / go-to-definition.
+enum Target {
+    /// `recv.field` where `field` comes from `owner` (a trait).
+    Field(ast::TraitDecl, String, ast::Type),
+    Trait(ast::TraitDecl),
+}
+fn identAt(line: &str, col: usize) -> Option<(usize, usize)> {
+    let b = line.as_bytes();
+    let isId = |c: u8| c.is_ascii_alphanumeric() || c == b'_';
+    let mut col = col.min(b.len());
+    if col == b.len() || !isId(b[col]) {
+        if col > 0 && isId(b[col - 1]) {
+            col -= 1;
+        } else {
+            return None;
+        }
+    }
+    let mut s = col;
+    while s > 0 && isId(b[s - 1]) {
+        s -= 1;
+    }
+    let mut e = col;
+    while e < b.len() && isId(b[e]) {
+        e += 1;
+    }
+    Some((s, e))
+}
+fn resolveTarget(
+    path: &Path,
+    libPath: &Path,
+    text: &str,
+    line0: usize,
+    col: usize,
+) -> Option<Target> {
+    let lineText = text.lines().nth(line0)?;
+    let (s, e) = identAt(lineText, col)?;
+    let word = &lineText[s..e];
+    let canon = std::fs::canonicalize(path).unwrap_or(path.to_path_buf());
+    let mut overrides = HashMap::new();
+    overrides.insert(canon, text.to_string());
+    let merged = plum_core::loadAndMergeWithOverrides(path, libPath, &overrides).ok()?;
+    if s > 0 && lineText.as_bytes()[s - 1] == b'.' {
+        let before = &lineText[..s - 1];
+        let rs = before
+            .rfind(|c: char| !(c.is_ascii_alphanumeric() || c == '_'))
+            .map(|i| i + 1)
+            .unwrap_or(0);
+        let receiver = &before[rs..];
+        let tree = Backend::parseTree(text);
+        let own = plum_core::AstParser::new(text).parseSource(tree.root_node());
+        let (global_env, methods, enum_variants, enum_params) =
+            plum_checker::buildGlobalTables(&merged);
+        let min_required = plum_checker::buildMinRequiredArgs(&merged);
+        let primitive_generics = plum_checker::buildPrimitiveGenerics(&merged);
+        let statics = plum_checker::buildStaticMethods(&merged);
+        let ctx = plum_checker::CheckCtx {
+            methods: &methods,
+            enum_variants: &enum_variants,
+            enum_params: &enum_params,
+            min_required: &min_required,
+            primitive_generics: &primitive_generics,
+            statics: Some(&statics),
+        };
+        let f = completion::enclosingFn(&own, line0 + 1);
+        let ty = completion::receiverType(f, receiver, &global_env, &ctx)?;
+        let owner = plum_checker::methodReceiverName(&ty)?;
+        for t in &merged.traits {
+            let Some(field) = t.fields.iter().find(|x| x.name == word) else {
+                continue;
+            };
+            // The trait itself, or a record that is one of its union variants.
+            let embeds = t.name == owner
+                || merged.items.iter().any(|i| {
+                    matches!(i, ast::Item::Enum(en) if en.isTrait && en.name == t.name
+                        && en.variants.iter().any(|v| {
+                            v.name == owner
+                                || v.name == format!("{}__{}", t.name, owner)
+                                || v.member.as_ref().is_some_and(|m| m.name == owner)
+                        }))
+                });
+            if embeds {
+                return Some(Target::Field(t.clone(), word.to_string(), field.ty.clone()));
+            }
+        }
+        return None;
+    }
+    merged
+        .traits
+        .iter()
+        .find(|t| t.name == word)
+        .map(|t| Target::Trait(t.clone()))
+}
+fn hoverAt(path: &Path, libPath: &Path, text: &str, line0: usize, col: usize) -> Option<String> {
+    match resolveTarget(path, libPath, text, line0, col)? {
+        Target::Field(t, name, ty) => Some(format!(
+            "{}: {} (from {})",
+            name,
+            completion::typeText(&ty),
+            t.name
+        )),
+        Target::Trait(t) => Some(format!("trait {}", t.name)),
+    }
+}
+/// Locates `needle` (a trait name or one of its fields) in the trait's declaration.
+fn definitionAt(
+    path: &Path,
+    libPath: &Path,
+    text: &str,
+    line0: usize,
+    col: usize,
+) -> Option<(PathBuf, u32, u32)> {
+    let target = resolveTarget(path, libPath, text, line0, col)?;
+    let (t, field) = match &target {
+        Target::Field(t, name, _) => (t, Some(name.as_str())),
+        Target::Trait(t) => (t, None),
+    };
+    let canon = std::fs::canonicalize(path).unwrap_or(path.to_path_buf());
+    let mut overrides = HashMap::new();
+    overrides.insert(canon.clone(), text.to_string());
+    let merged = plum_core::loadAndMergeWithOverrides(path, libPath, &overrides).ok()?;
+    let mut files: Vec<String> = vec![path.to_string_lossy().into_owned()];
+    for i in &merged.items {
+        if let ast::Item::Fn(f) = i {
+            if !files.contains(&f.file) {
+                files.push(f.file.clone());
+            }
+        }
+    }
+    let header = format!("trait {}", t.name);
+    for file in files {
+        let p = PathBuf::from(&file);
+        let content = if std::fs::canonicalize(&p).unwrap_or(p.clone()) == canon {
+            text.to_string()
+        } else {
+            match std::fs::read_to_string(&p) {
+                Ok(c) => c,
+                Err(_) => continue,
+            }
+        };
+        let lines: Vec<&str> = content.lines().collect();
+        let Some(ln) = lines.get(t.line.saturating_sub(1)) else {
+            continue;
+        };
+        let Some(hc) = ln.find(&header) else { continue };
+        let nameCol = hc + "trait ".len();
+        let Some(field) = field else {
+            return Some((p, t.line as u32 - 1, nameCol as u32));
+        };
+        for (off, l) in lines.iter().enumerate().skip(t.line - 1).take(40) {
+            let from = if off == t.line - 1 { nameCol + t.name.len() } else { 0 };
+            let mut at = from;
+            while let Some(i) = l[at..].find(field) {
+                let c = at + i;
+                let after = l[c + field.len()..].trim_start();
+                let boundary = c == 0 || !l.as_bytes()[c - 1].is_ascii_alphanumeric() && l.as_bytes()[c - 1] != b'_';
+                if boundary && after.starts_with(':') {
+                    return Some((p, off as u32, c as u32));
+                }
+                at = c + field.len();
+            }
+        }
+    }
+    None
 }
 #[tokio::main]
@@ -366,6 +588,55 @@ mod tests {
         PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("..")
     }
+    const TRAIT_SRC: &str = "module t\nimport std/Int\nimport std/Bool\n\nrecord Vec2(x: Int, y: Int)\n\ntrait Entity(pos: Vec2, hp: Int) =\n  fun alive(self) -> Bool = self.hp > 0\n\nrecord House(Entity, rooms: Int)\n\nfun main() =\n  h := House(pos: Vec2(x: 1, y: 2), hp: 5, rooms: 3)\n  h.pos\n  e: Entity = h\n  e.zzzzzz\n";
+    fn traitFile(tag: &str) -> PathBuf {
+        let dir = std::env::temp_dir().join(format!("plum-lsp-trait-{}-{}", tag, std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("t.plum");
+        std::fs::write(&path, TRAIT_SRC).unwrap();
+        path
+    }
+    #[test]
+    fn hover_embedded_field() {
+        let path = traitFile("hover");
+        // line 12 (0-based 11): `  h.pos`, cursor on `pos`.
+        let h = hoverAt(&path, &repoRoot(), TRAIT_SRC, 13, 5).expect("hover");
+        assert!(h.contains("pos: Vec2 (from Entity)"), "{h}");
+    }
+    #[test]
+    fn complete_trait_value() {
+        let path = traitFile("complete");
+        let items = memberCompletionFor(&path, &repoRoot(), TRAIT_SRC, 16, "e");
+        let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
+        for want in ["pos", "hp", "alive"] {
+            assert!(labels.contains(&want), "missing {want} in {labels:?}");
+        }
+        assert!(!labels.iter().any(|l| l.starts_with("__")), "{labels:?}");
+        let rec = memberCompletionFor(&path, &repoRoot(), TRAIT_SRC, 14, "h");
+        let rl: Vec<&str> = rec.iter().map(|i| i.label.as_str()).collect();
+        assert!(!rl.iter().any(|l| l.starts_with("__")), "{rl:?}");
+    }
+    #[test]
+    fn goto_embedded_field() {
+        let path = traitFile("goto");
+        let (f, l, c) = definitionAt(&path, &repoRoot(), TRAIT_SRC, 13, 5).expect("def");
+        assert_eq!(f, path);
+        assert_eq!((l, c), (6, 13), "pos in `trait Entity(pos: ...`");
+    }
+    #[test]
+    fn goto_trait_name() {
+        let path = traitFile("name");
+        // `record House(Entity, ...` is line index 7; `Entity` starts at col 13.
+        let (f, l, c) = definitionAt(&path, &repoRoot(), TRAIT_SRC, 9, 15).expect("def");
+        assert_eq!(f, path);
+        assert_eq!((l, c), (6, 6));
+    }
     /// The whole diagnostic path (`publishAll`: syntax diagnostics, then the
     /// two-pass checker) must find nothing wrong in the Seq/fun*/for example.
     #[test]