Merge pull request #100 from Pivot-Studio/feat/typehint

Feat/typehint

Author: Chronostasys

.github/workflows/release.yml

@@ -168,7 +168,6 @@ jobs:
           mkdir -p ${{ matrix.config.debdir }}/pl
           cp -r ${{ matrix.config.dir }}/* ${{ matrix.config.debdir }}/pl
           rm ${{ matrix.config.debdir }}/pl/plc
-
       - uses: Pivot-Studio/build-deb-action@master
         if: ${{ matrix.config.os == 'ubuntu-latest' }}
         id: build-deb
@@ -264,15 +263,12 @@ jobs:
           # Optional - multiline string.
           depends_on: |
             "llvm@14"
-
           # Custom install command for your formula.
           # Required - string.
           install: |
             lib.install Dir["./planglib"]
                 lib.install "./libvm.a"
                 bin.install "./plc"
-
-
           # Custom test command for your formula so you can run `brew test`.
           # Optional - string.
           # test: 'assert_match("my script output", shell_output("my-script-command"))'
@@ -312,4 +308,4 @@ jobs:
 
           # Logs debugging info to console.
           # Default is shown - boolean.
-          debug: true
+          debug: true

deb/DEBIAN/postinst

@@ -17,4 +17,4 @@ if [ "$1" = configure ]; then
     echo "see https://apt.llvm.org/ for more details"
     echo "-------------------------------------------------------------------"
     echo "${NC}"
-fi
+fi

src/ast/accumulators.rs

@@ -1,7 +1,8 @@
 use std::{cell::RefCell, path::PathBuf, rc::Rc};
 
 use lsp_types::{
-    CompletionItem, GotoDefinitionResponse, Hover, InlayHint, Location, SemanticTokens, TextEdit,
+    CompletionItem, DocumentSymbol, GotoDefinitionResponse, Hover, InlayHint, Location,
+    SemanticTokens, TextEdit,
 };
 
 use super::ctx::PLDiag;
@@ -31,3 +32,5 @@ pub struct ModBuffer(PathBuf);
 pub struct PLFormat(Vec<TextEdit>);
 #[salsa::accumulator]
 pub struct Hints(Vec<InlayHint>);
+#[salsa::accumulator]
+pub struct DocSymbols(Vec<DocumentSymbol>);

src/ast/compiler.rs

@@ -99,6 +99,7 @@ pub enum ActionType {
     Fmt,
     LspFmt,
     Hint,
+    DocSymbol,
 }
 
 #[cfg(feature = "jit")]

src/ast/ctx.rs

@@ -26,6 +26,7 @@ use lsp_types::CompletionItem;
 use lsp_types::CompletionItemKind;
 use lsp_types::Diagnostic;
 use lsp_types::DiagnosticSeverity;
+use lsp_types::DocumentSymbol;
 use lsp_types::GotoDefinitionResponse;
 use lsp_types::Hover;
 use lsp_types::HoverContents;
@@ -35,6 +36,7 @@ use lsp_types::InsertTextFormat;
 use lsp_types::Location;
 use lsp_types::MarkedString;
 use lsp_types::SemanticTokenType;
+use lsp_types::SymbolKind;
 use lsp_types::Url;
 use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
@@ -95,6 +97,7 @@ pub struct Ctx<'a, 'ctx> {
     pub ditypes_placeholder: Rc<RefCell<FxHashMap<String, RefCell<Vec<MemberType<'ctx>>>>>>, // hold the generated debug info type place holder
     pub ditypes: Rc<RefCell<FxHashMap<String, DIType<'ctx>>>>, // hold the generated debug info type
     pub hints: Rc<RefCell<Box<Vec<InlayHint>>>>,
+    pub doc_symbols: Rc<RefCell<Box<Vec<DocumentSymbol>>>>,
     pub semantic_tokens_builder: Rc<RefCell<Box<SemanticTokensBuilder>>>, // semantic token builder
     pub goto_def: Rc<Cell<Option<GotoDefinitionResponse>>>, // hold the goto definition result
     pub completion_items: Rc<Cell<Vec<CompletionItem>>>,    // hold the completion items
@@ -493,7 +496,7 @@ impl PLType {
             PLType::PRIMITIVE(pri) => pri.get_name(),
             PLType::ARR(arr) => format!("[{} * {}]", arr.element_type.get_name(), arr.size),
             PLType::VOID => "void".to_string(),
-            PLType::POINTER(p) => "&".to_string() + &p.get_name(),
+            PLType::POINTER(p) => "*".to_string() + &p.get_name(),
         }
     }
 
@@ -792,6 +795,19 @@ impl Field {
             offset + debug_type.get_size_in_bits(),
         )
     }
+    pub fn get_doc_symbol<'a, 'ctx>(&self, ctx: &Ctx<'a, 'ctx>) -> DocumentSymbol {
+        #[allow(deprecated)]
+        DocumentSymbol {
+            name: self.name.clone(),
+            detail: Some(self.pltype.get_type(ctx).unwrap().get_name()),
+            kind: SymbolKind::FIELD,
+            tags: None,
+            deprecated: None,
+            range: self.range.to_diag_range(),
+            selection_range: self.range.to_diag_range(),
+            children: None,
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -804,6 +820,7 @@ pub struct FNType {
     pub range: Range,
     pub refs: Rc<RefCell<Vec<Location>>>,
     pub doc: Vec<Box<NodeEnum>>,
+    pub method: bool,
 }
 
 impl TryFrom<PLType> for FNType {
@@ -838,6 +855,47 @@ impl FNType {
             .add_function(&self.llvmname, fn_type, Some(Linkage::External));
         fn_value
     }
+    pub fn get_doc_symbol(&self) -> DocumentSymbol {
+        #[allow(deprecated)]
+        DocumentSymbol {
+            name: if self.method {
+                self.name.split("::").last().unwrap().to_string()
+            } else {
+                self.name.clone()
+            },
+            detail: Some(self.get_signature()),
+            kind: if self.method {
+                SymbolKind::METHOD
+            } else {
+                SymbolKind::FUNCTION
+            },
+            tags: None,
+            deprecated: None,
+            range: self.range.to_diag_range(),
+            selection_range: self.range.to_diag_range(),
+            children: None,
+        }
+    }
+    pub fn get_signature(&self) -> String {
+        let mut params = String::new();
+        if !self.param_name.is_empty() {
+            if !self.method {
+                params += &format!(
+                    "{}: {}",
+                    self.param_name[0],
+                    self.param_pltypes[0].get_name()
+                );
+            }
+            for i in 1..self.param_name.len() {
+                params += &format!(
+                    ", {}: {}",
+                    self.param_name[i],
+                    self.param_pltypes[i].get_name()
+                );
+            }
+        }
+        format!("fn ({}) {}", params, self.ret_pltype.get_name())
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -918,6 +976,24 @@ impl STType {
     pub fn get_st_full_name(&self) -> String {
         format!("{}..{}", self.path, self.name)
     }
+    pub fn get_doc_symbol<'a, 'ctx>(&self, ctx: &Ctx<'a, 'ctx>) -> DocumentSymbol {
+        let children: Vec<DocumentSymbol> = self
+            .ordered_fields
+            .iter()
+            .map(|order_field| order_field.get_doc_symbol(ctx))
+            .collect();
+        #[allow(deprecated)]
+        DocumentSymbol {
+            name: self.name.clone(),
+            detail: None,
+            kind: SymbolKind::STRUCT,
+            tags: None,
+            deprecated: None,
+            range: self.range.to_diag_range(),
+            selection_range: self.range.to_diag_range(),
+            children: Some(children),
+        }
+    }
 }
 
 fn add_primitive_types<'a, 'ctx>(ctx: &mut Ctx<'a, 'ctx>) {
@@ -1082,6 +1158,7 @@ impl<'a, 'ctx> Ctx<'a, 'ctx> {
             lspparams: completion,
             refs: Rc::new(Cell::new(None)),
             hints: Rc::new(RefCell::new(Box::new(vec![]))),
+            doc_symbols: Rc::new(RefCell::new(Box::new(vec![]))),
             semantic_tokens_builder: Rc::new(RefCell::new(Box::new(SemanticTokensBuilder::new(
                 src_file_path.to_string(),
             )))),
@@ -1129,6 +1206,7 @@ impl<'a, 'ctx> Ctx<'a, 'ctx> {
             lspparams: self.lspparams.clone(),
             refs: self.refs.clone(),
             hints: self.hints.clone(),
+            doc_symbols: self.doc_symbols.clone(),
             semantic_tokens_builder: self.semantic_tokens_builder.clone(),
             goto_def: self.goto_def.clone(),
             completion_items: self.completion_items.clone(),
@@ -1227,7 +1305,7 @@ impl<'a, 'ctx> Ctx<'a, 'ctx> {
         &mut self,
         name: String,
         pv: PointerValue<'ctx>,
-        tp: PLType,
+        pltype: PLType,
         range: Range,
         is_const: bool,
     ) -> Result<(), PLDiag> {
@@ -1237,9 +1315,10 @@ impl<'a, 'ctx> Ctx<'a, 'ctx> {
         let refs = Rc::new(RefCell::new(vec![]));
         if is_const {
             self.plmod
-                .add_global_symbol(name, tp, range, refs.clone())?;
+                .add_global_symbol(name, pltype.clone(), range, refs.clone())?;
         } else {
-            self.table.insert(name, (pv, tp, range, refs.clone()));
+            self.table
+                .insert(name, (pv, pltype.clone(), range, refs.clone()));
         }
         self.send_if_go_to_def(range, range, self.plmod.path.clone());
         self.set_if_refs(refs, range);
@@ -1299,14 +1378,25 @@ impl<'a, 'ctx> Ctx<'a, 'ctx> {
         set.insert(name);
     }
 
-    pub fn add_type(&mut self, name: String, tp: PLType, range: Range) -> Result<(), PLDiag> {
+    pub fn add_type(&mut self, name: String, pltype: PLType, range: Range) -> Result<(), PLDiag> {
         if self.plmod.types.contains_key(&name) {
             return Err(self.add_err(range, ErrorCode::REDEFINE_TYPE));
         }
         self.send_if_go_to_def(range, range, self.plmod.path.clone());
-        self.plmod.types.insert(name, tp.clone());
+        self.plmod.types.insert(name, pltype.clone());
         Ok(())
     }
+    pub fn add_doc_symbols(&mut self, pltype: PLType) {
+        match &pltype {
+            PLType::FN(f) => {
+                if !f.method {
+                    self.doc_symbols.borrow_mut().push(f.get_doc_symbol())
+                }
+            }
+            PLType::STRUCT(st) => self.doc_symbols.borrow_mut().push(st.get_doc_symbol(self)),
+            _ => {}
+        }
+    }
 
     pub fn add_err(&self, range: Range, code: ErrorCode) -> PLDiag {
         let dia = PLDiag::new_error(range, code);

src/ast/node/function.rs

@@ -105,6 +105,13 @@ impl Node for FuncDefNode {
             }
         }
         ctx.push_semantic_token(self.typenode.ret.range(), SemanticTokenType::TYPE, 0);
+        let res = ctx.get_type(self.typenode.id.as_str(), self.range);
+        if res.is_err() {
+            let diag = res.unwrap_err();
+            ctx.add_diag(diag.clone());
+            return Err(diag);
+        }
+        let pltype = res.unwrap().clone();
         if let Some(body) = self.body.as_mut() {
             let subroutine_type = ctx.dibuilder.create_subroutine_type(
                 ctx.diunit.get_file(),
@@ -126,15 +133,7 @@ impl Node for FuncDefNode {
                 false,
             );
             // add function
-            let func;
-            let res = ctx.get_type(self.typenode.id.as_str(), self.range);
-            if res.is_err() {
-                let diag = res.unwrap_err();
-                ctx.add_diag(diag.clone());
-                return Err(diag);
-            }
-            let fu = res.unwrap();
-            func = match fu {
+            let func = match &pltype {
                 PLType::FN(fu) => fu.get_or_insert_fn(ctx),
                 _ => return Ok((None, None, TerminatorEnum::NONE)),
             };
@@ -238,9 +237,9 @@ impl Node for FuncDefNode {
             }
             ctx.nodebug_builder.position_at_end(allocab);
             ctx.nodebug_builder.build_unconditional_branch(entry);
-            return Ok((None, None, TerminatorEnum::NONE));
+            return Ok((None, Some(pltype.clone()), TerminatorEnum::NONE));
         }
-        Ok((None, None, TerminatorEnum::NONE))
+        Ok((None, Some(pltype.clone()), TerminatorEnum::NONE))
     }
 }
 
@@ -399,6 +398,7 @@ impl FuncTypeNode {
             } else {
                 ctx.plmod.get_full_name(&self.id)
             },
+            method: receiver.is_some(),
         };
         if let Some(mut receiver) = receiver {
             receiver
@@ -411,7 +411,8 @@ impl FuncTypeNode {
         let res = ftp.get_or_insert_fn(ctx);
         let pltype = PLType::FN(ftp);
         ctx.set_if_refs_tp(&pltype, self.range);
-        ctx.add_type(self.id.clone(), pltype, self.range)?;
+        ctx.add_type(self.id.clone(), pltype.clone(), self.range)?;
+        ctx.add_doc_symbols(pltype);
         Ok(res)
     }
 }

src/ast/node/implement.rs

@@ -1,6 +1,7 @@
 use super::*;
 use crate::{ast::ctx::Ctx, utils::read_config::enter};
 use internal_macro::range;
+use lsp_types::{DocumentSymbol, SymbolKind};
 
 #[range]
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -33,9 +34,34 @@ impl Node for ImplNode {
     }
     fn emit<'a, 'ctx>(&'a mut self, ctx: &mut Ctx<'a, 'ctx>) -> NodeResult<'ctx> {
         _ = self.target.emit_highlight(ctx);
+        let mut method_docsymbols = vec![];
         for method in &mut self.methods {
-            _ = method.emit(ctx);
+            let res = method.emit(ctx);
+            if res.is_err() {
+                continue;
+            }
+            let (_, pltype, _) = res.unwrap();
+            if pltype.is_none() {
+                continue;
+            }
+            let f = match pltype.unwrap() {
+                PLType::FN(f) => f,
+                _ => continue,
+            };
+            method_docsymbols.push(f.get_doc_symbol());
         }
+        #[allow(deprecated)]
+        let docsymbol = DocumentSymbol {
+            name: format!("impl {}", self.target.format(0, "")),
+            detail: None,
+            kind: SymbolKind::OBJECT,
+            tags: None,
+            deprecated: None,
+            range: self.range.to_diag_range(),
+            selection_range: self.range.to_diag_range(),
+            children: Some(method_docsymbols),
+        };
+        ctx.doc_symbols.borrow_mut().push(docsymbol);
         Ok((None, None, TerminatorEnum::NONE))
     }
 }

src/ast/node/program.rs

@@ -300,6 +300,10 @@ pub fn emit_file(db: &dyn Db, params: ProgramEmitParam) -> ModWrapper {
         let hints = ctx.hints.take();
         Hints::push(db, *hints);
     }
+    if action == ActionType::DocSymbol {
+        let docs = ctx.doc_symbols.take();
+        DocSymbols::push(db, *docs);
+    }
     if let Some(c) = ctx.goto_def.take() {
         GotoDef::push(db, c);
     }

src/ast/node/types.rs

@@ -315,7 +315,7 @@ impl StructDefNode {
                 .collect::<Vec<_>>(),
             false,
         );
-        let stu = PLType::STRUCT(STType {
+        let pltype = PLType::STRUCT(STType {
             name: name.to_string(),
             path: ctx.plmod.path.clone(),
             fields,
@@ -325,8 +325,9 @@ impl StructDefNode {
             doc: self.doc.clone(),
             methods: FxHashMap::default(),
         });
-        ctx.set_if_refs_tp(&stu, self.range);
-        _ = ctx.plmod.replace_type(name, stu.clone());
+        ctx.set_if_refs_tp(&pltype, self.range);
+        _ = ctx.plmod.replace_type(name, pltype.clone());
+        ctx.add_doc_symbols(pltype);
         ctx.save_if_comment_doc_hover(self.range, Some(self.doc.clone()));
         Ok(())
     }