optimize: reuse template compilation result for typescript

Author: LastLeaf

Cargo.lock

@@ -16,7 +16,7 @@ compact_str = "0.8.0"
 cssparser = "0.34.0"
 cssparser-color = "0.2.0"
 futures = "0.3.31"
-glass-easel-template-compiler = "0.15.2"
+glass-easel-template-compiler = "0.15.3"
 itertools = "0.13.0"
 log = "0.4.22"
 lsp-server = "0.7.7"

Cargo.toml

@@ -6,14 +6,13 @@ use std::{
 
 use futures::StreamExt;
 use glass_easel_template_compiler::{
-    parse::{ParseError, ParseErrorKind, ParseErrorLevel, Template},
-    TmplGroup,
+    parse::{ParseError, ParseErrorKind, ParseErrorLevel, Template}, TmplConvertedExpr, TmplGroup
 };
 use lsp_types::{Diagnostic, DiagnosticSeverity, Position, Range};
 use tokio::sync::Mutex as AsyncMutex;
 
 use super::{FileLang, ServerContextOptions};
-use crate::wxss::{self, StyleSheet};
+use crate::wxss::{self, Location, StyleSheet};
 
 #[derive(Debug)]
 pub(crate) struct FileContentMetadata {
@@ -110,6 +109,7 @@ pub(crate) struct Project {
     file_contents: HashMap<PathBuf, FileContentMetadata>,
     json_config_map: HashMap<PathBuf, JsonConfig>,
     template_group: TmplGroup,
+    cached_wxml_converted_expr: HashMap<String, TmplConvertedExpr>,
     style_sheet_map: HashMap<PathBuf, StyleSheet>,
     enable_other_ss: bool,
 }
@@ -121,6 +121,7 @@ impl Default for Project {
             file_contents: HashMap::new(),
             json_config_map: HashMap::new(),
             template_group: TmplGroup::new(),
+            cached_wxml_converted_expr: HashMap::new(),
             style_sheet_map: HashMap::new(),
             enable_other_ss: false,
         }
@@ -186,6 +187,7 @@ impl Project {
             file_contents: HashMap::new(),
             json_config_map: HashMap::new(),
             template_group: TmplGroup::new(),
+            cached_wxml_converted_expr: HashMap::new(),
             style_sheet_map: HashMap::new(),
             enable_other_ss: options.enable_other_ss,
         }
@@ -521,6 +523,7 @@ impl Project {
     fn cleanup_wxml(&mut self, abs_path: &Path) -> anyhow::Result<()> {
         let tmpl_path = self.unix_rel_path_or_fallback(&abs_path);
         self.template_group.remove_tmpl(&tmpl_path);
+        self.cached_wxml_converted_expr.remove(&tmpl_path);
         self.file_contents.remove(abs_path);
         Ok(())
     }
@@ -557,6 +560,37 @@ impl Project {
         self.template_group.list_template_trees()
     }
 
+    pub(crate) fn wxml_converted_expr_release(&mut self, abs_path: &Path) -> bool {
+        let tmpl_path = self.unix_rel_path_or_fallback(&abs_path);
+        self.cached_wxml_converted_expr.remove(&tmpl_path).is_some()
+    }
+
+    pub(crate) fn wxml_converted_expr_code(&mut self, abs_path: &Path, ts_env: &str) -> anyhow::Result<String> {
+        let tmpl_path = self.unix_rel_path_or_fallback(&abs_path);
+        let expr = self.template_group.get_tmpl_converted_expr(&tmpl_path, ts_env)?;
+        let code = expr.code().to_string();
+        self.cached_wxml_converted_expr.insert(tmpl_path, expr);
+        Ok(code)
+    }
+
+    pub(crate) fn wxml_converted_expr_get_source_location(&self, abs_path: &Path, loc: Location) -> Option<Location> {
+        let tmpl_path = self.unix_rel_path_or_fallback(&abs_path);
+        self.cached_wxml_converted_expr
+            .get(&tmpl_path)
+            .and_then(|x| x.get_source_location(loc))
+    }
+
+    pub(crate) fn wxml_converted_expr_get_token_at_source_position(
+        &self,
+        abs_path: &Path,
+        pos: crate::wxss::Position,
+    ) -> Option<(Location, crate::wxss::Position)> {
+        let tmpl_path = self.unix_rel_path_or_fallback(&abs_path);
+        self.cached_wxml_converted_expr
+            .get(&tmpl_path)
+            .and_then(|x| x.get_token_at_source_position(pos))
+    }
+
     pub(crate) fn for_each_json_config(&self, mut f: impl FnMut(&Path, &JsonConfig)) {
         for (p, json_config) in self.json_config_map.iter() {
             f(p, json_config);

pnpm-lock.yaml

@@ -15,6 +15,7 @@ mod reference;
 mod semantic;
 mod symbol;
 mod utils;
+mod wxml_ts;
 mod wxml_utils;
 mod wxs;
 mod wxss;
@@ -100,6 +101,7 @@ async fn handle_request(
         ($name:expr, $f:path) => {
             if method.as_str() == $name {
                 let params = serde_json::from_value(params).map_err(|err| {
+                    log::error!("Invalid params: {:?}", err);
                     anyhow::Error::from(err).context(format!("Invalid params on {:?}", method))
                 })?;
                 let ret = $f(ctx, params).await?;
@@ -115,6 +117,10 @@ async fn handle_request(
 
     // handlers for each method
     handler!("shutdown", cleanup);
+    handler!("glassEaselAnalyzer/tmplConvertedExprRelease", wxml_ts::tmpl_converted_expr_release);
+    handler!("glassEaselAnalyzer/tmplConvertedExprCode", wxml_ts::tmpl_converted_expr_code);
+    handler!("glassEaselAnalyzer/tmplConvertedExprGetSourceLocation", wxml_ts::tmpl_converted_expr_get_source_location);
+    handler!("glassEaselAnalyzer/tmplConvertedExprGetTokenAtSourcePosition", wxml_ts::tmpl_converted_expr_get_token_at_source_position);
     handler!("textDocument/foldingRange", folding::folding_range);
     handler!("textDocument/semanticTokens/full", semantic::tokens_full);
     handler!("textDocument/semanticTokens/range", semantic::tokens_range);

src/context/project.rs

@@ -97,7 +97,7 @@ pub(crate) fn location_to_lsp_range(loc: &Location) -> lsp_types::Range {
     }
 }
 
-pub(crate) fn _lsp_range_to_location(loc: &lsp_types::Range) -> Location {
+pub(crate) fn lsp_range_to_location(loc: &lsp_types::Range) -> Location {
     let start = Position {
         line: loc.start.line,
         utf16_col: loc.start.character,

src/lib.rs

@@ -0,0 +1,166 @@
+use lsp_types::{Position, Range, Url};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    context::FileLang, utils::{location_to_lsp_range, lsp_range_to_location}, ServerContext
+};
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TmplConvertedExprReleaseParams {
+    text_document_uri: Url,
+}
+
+pub(crate) async fn tmpl_converted_expr_release(
+    ctx: ServerContext,
+    params: TmplConvertedExprReleaseParams,
+) -> anyhow::Result<bool> {
+    let ret = ctx
+        .clone()
+        .project_thread_task(
+            &params.text_document_uri,
+            move |project, abs_path, file_lang| -> anyhow::Result<bool> {
+                let success = if let Some(_) = project.cached_file_content(&abs_path) {
+                    match file_lang {
+                        FileLang::Wxml => {
+                            project.wxml_converted_expr_release(&abs_path)
+                        }
+                        _ => false,
+                    }
+                } else {
+                    false
+                };
+                Ok(success)
+            },
+        )
+        .await??;
+    Ok(ret)
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TmplConvertedExprCodeParams {
+    text_document_uri: Url,
+    ts_env: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TmplConvertedExprCode {
+    code: String,
+}
+
+pub(crate) async fn tmpl_converted_expr_code(
+    ctx: ServerContext,
+    params: TmplConvertedExprCodeParams,
+) -> anyhow::Result<Option<TmplConvertedExprCode>> {
+    let ret = ctx
+        .clone()
+        .project_thread_task(
+            &params.text_document_uri,
+            move |project, abs_path, file_lang| -> anyhow::Result<Option<TmplConvertedExprCode>> {
+                let code = if let Some(_) = project.cached_file_content(&abs_path) {
+                    match file_lang {
+                        FileLang::Wxml => {
+                            let code = project.wxml_converted_expr_code(&abs_path, &params.ts_env)?;
+                            Some(TmplConvertedExprCode { code })
+                        }
+                        _ => None,
+                    }
+                } else {
+                    None
+                };
+                Ok(code)
+            },
+        )
+        .await??;
+    Ok(ret)
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TmplConvertedExprGetSourceLocationParams {
+    text_document_uri: Url,
+    loc: Range,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TmplConvertedExprGetSourceLocation {
+    src: Range,
+}
+
+pub(crate) async fn tmpl_converted_expr_get_source_location(
+    ctx: ServerContext,
+    params: TmplConvertedExprGetSourceLocationParams,
+) -> anyhow::Result<Option<TmplConvertedExprGetSourceLocation>> {
+    let ret = ctx
+        .clone()
+        .project_thread_task(
+            &params.text_document_uri,
+            move |project, abs_path, file_lang| -> anyhow::Result<Option<TmplConvertedExprGetSourceLocation>> {
+                let src_loc = if let Some(_) = project.cached_file_content(&abs_path) {
+                    match file_lang {
+                        FileLang::Wxml => {
+                            let loc = lsp_range_to_location(&params.loc);
+                            project.wxml_converted_expr_get_source_location(&abs_path, loc)
+                        }
+                        _ => None,
+                    }
+                } else {
+                    None
+                };
+                let src = src_loc.as_ref().map(|x| location_to_lsp_range(x));
+                Ok(src.map(|src| TmplConvertedExprGetSourceLocation { src }))
+            },
+        )
+        .await??;
+    Ok(ret)
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TmplConvertedExprGetTokenAtSourcePositionParams {
+    text_document_uri: Url,
+    pos: Position,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TmplConvertedExprGetTokenAtSourcePosition {
+    src: Range,
+    dest: Position
+}
+
+pub(crate) async fn tmpl_converted_expr_get_token_at_source_position(
+    ctx: ServerContext,
+    params: TmplConvertedExprGetTokenAtSourcePositionParams,
+) -> anyhow::Result<Option<TmplConvertedExprGetTokenAtSourcePosition>> {
+    let ret = ctx
+        .clone()
+        .project_thread_task(
+            &params.text_document_uri,
+            move |project, abs_path, file_lang| -> anyhow::Result<Option<TmplConvertedExprGetTokenAtSourcePosition>> {
+                let ret = if let Some(_) = project.cached_file_content(&abs_path) {
+                    match file_lang {
+                        FileLang::Wxml => {
+                            let pos = crate::wxss::Position { line: params.pos.line, utf16_col: params.pos.character };
+                            project.wxml_converted_expr_get_token_at_source_position(&abs_path, pos)
+                        }
+                        _ => None,
+                    }
+                } else {
+                    None
+                };
+                let ret = ret.map(|(src, dest)| {
+                    TmplConvertedExprGetTokenAtSourcePosition {
+                        src: location_to_lsp_range(&src),
+                        dest: Position { line: dest.line, character: dest.utf16_col },
+                    }
+                });
+                Ok(ret)
+            },
+        )
+        .await??;
+    Ok(ret)
+}