Merge remote-tracking branch 'origin/main' into merge

Author: xuhuanzy

.github/workflows/build.yml

@@ -17,16 +17,18 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - { os: ubuntu-22.04,   target: x86_64-unknown-linux-gnu,    platform: linux-x64,    cross: general }
-          - { os: ubuntu-22.04,   target: x86_64-unknown-linux-gnu,    platform: linux-x64,    cross: zigbuild, glibc: 2.17 }
-          - { os: ubuntu-22.04,   target: aarch64-unknown-linux-gnu,   platform: linux-arm64,  cross: zigbuild, glibc: 2.17 }
-          - { os: ubuntu-22.04,   target: riscv64gc-unknown-linux-gnu, platform: linux-riscv64,cross: cross }
-          - { os: ubuntu-22.04,   target: x86_64-unknown-linux-musl,   platform: linux-musl,   cross: cross }
-          - { os: macos-latest,   target: x86_64-apple-darwin,         platform: darwin-x64,   cross: general-macos-intel }
-          - { os: macos-latest,   target: aarch64-apple-darwin,        platform: darwin-arm64, cross: general }
-          - { os: windows-latest, target: x86_64-pc-windows-msvc,      platform: win32-x64,    cross: general }
-          - { os: windows-latest, target: i686-pc-windows-msvc,        platform: win32-ia32,   cross: general }
-          - { os: windows-latest, target: aarch64-pc-windows-msvc,     platform: win32-arm64,  cross: general }
+          - { os: ubuntu-22.04,   target: x86_64-unknown-linux-gnu,    platform: linux-x64,    cross: general,  crate: emmylua_ls }
+          - { os: ubuntu-22.04,   target: x86_64-unknown-linux-gnu,    platform: linux-x64,    cross: zigbuild, crate: emmylua_ls, glibc: 2.17 }
+          - { os: ubuntu-22.04,   target: aarch64-unknown-linux-gnu,   platform: linux-arm64,  cross: zigbuild, crate: emmylua_ls, glibc: 2.17 }
+          - { os: ubuntu-22.04,   target: riscv64gc-unknown-linux-gnu, platform: linux-riscv64,cross: cross,    crate: emmylua_ls }
+          - { os: ubuntu-22.04,   target: x86_64-unknown-linux-musl,   platform: linux-musl,   cross: cross,    crate: emmylua_ls }
+          - { os: macos-latest,   target: x86_64-apple-darwin,         platform: darwin-x64,   cross: general-macos-intel, crate: emmylua_ls }
+          - { os: macos-latest,   target: aarch64-apple-darwin,        platform: darwin-arm64, cross: general,  crate: emmylua_ls }
+          - { os: windows-latest, target: x86_64-pc-windows-msvc,      platform: win32-x64,    cross: general,  crate: emmylua_ls }
+          - { os: windows-latest, target: i686-pc-windows-msvc,        platform: win32-ia32,   cross: general,  crate: emmylua_ls }
+          - { os: windows-latest, target: aarch64-pc-windows-msvc,     platform: win32-arm64,  cross: general,  crate: emmylua_ls }
+          - { os: ubuntu-22.04,   target: x86_64-unknown-linux-gnu,    platform: linux-x64,    cross: general,  crate: emmylua_check }
+          - { os: ubuntu-22.04,   target: x86_64-unknown-linux-gnu,    platform: linux-x64,    cross: general,  crate: emmylua_doc_cli }
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
@@ -43,47 +45,46 @@ jobs:
         if: ${{ matrix.cross == 'general' }}
         run: |
           rustup target add ${{ matrix.target }}
-          cargo build --release --target ${{ matrix.target }}  -p emmylua_ls
+          cargo build --release --target ${{ matrix.target }}  -p ${{ matrix.crate }}
       - name: Build - cross
         if: ${{ matrix.cross == 'cross' }}
         run: |
           cargo install cross
-          cross build --release --target ${{ matrix.target }} -p emmylua_ls
+          cross build --release --target ${{ matrix.target }} -p ${{ matrix.crate }}
       - name: Build -zigbuild
         if: ${{ matrix.cross == 'zigbuild' }}
         run: |
           rustup target add ${{ matrix.target }}
           cargo install --locked cargo-zigbuild
           pip3 install ziglang
-          cargo zigbuild --release --target ${{ matrix.target }}.${{ matrix.glibc }} -p emmylua_ls
+          cargo zigbuild --release --target ${{ matrix.target }}.${{ matrix.glibc }} -p ${{ matrix.crate }}
       - name: Build - general macos-intel
         if: ${{ matrix.cross == 'general-macos-intel' }}
         run: |
           rustup target add ${{ matrix.target }}
-          cargo build --release --target ${{ matrix.target }} -p emmylua_ls
-          otool -l ./target/${{ matrix.target }}/release/emmylua_ls | grep -A4 "LC_BUILD_VERSION\|LC_VERSION_MIN_MACOSX"
+          cargo build --release --target ${{ matrix.target }} -p ${{ matrix.crate }}
       - name: copy-binary
         if: ${{ matrix.os != 'windows-latest'  }}
         run: |
           mkdir -p ${{ github.workspace }}/artifact/
-          cp ${{ github.workspace }}/target/${{ matrix.target }}/release/emmylua_ls ${{ github.workspace }}/artifact/
+          cp ${{ github.workspace }}/target/${{ matrix.target }}/release/${{ matrix.crate }} ${{ github.workspace }}/artifact/
       - name: copy-binary-windows
         if: ${{ matrix.os == 'windows-latest'  }}
         run: |
           mkdir -p ${{ github.workspace }}/artifact/
-          cp ${{ github.workspace }}/target/${{ matrix.target }}/release/emmylua_ls.exe ${{ github.workspace }}/artifact/
+          cp ${{ github.workspace }}/target/${{ matrix.target }}/release/${{ matrix.crate }}.exe ${{ github.workspace }}/artifact/
         shell: pwsh
       - name: Upload
         if: ${{ matrix.cross != 'zigbuild'  }}
         uses: actions/upload-artifact@v4
         with: 
-          name: emmylua_ls-${{ matrix.platform }}
+          name: ${{ matrix.crate }}-${{ matrix.platform }}
           path: ${{ github.workspace }}/artifact/
       - name: Upload zigbuild
         if: ${{ matrix.cross == 'zigbuild'  }}
         uses: actions/upload-artifact@v4
         with: 
-          name: emmylua_ls-${{ matrix.platform }}-glibc.${{ matrix.glibc }}
+          name: ${{ matrix.crate }}-${{ matrix.platform }}-glibc.${{ matrix.glibc }}
           path: ${{ github.workspace }}/artifact/
   release:
     needs: build
@@ -101,6 +102,8 @@ jobs:
           chmod +x emmylua_ls-linux-riscv64/emmylua_ls
           chmod +x emmylua_ls-darwin-x64/emmylua_ls
           chmod +x emmylua_ls-darwin-arm64/emmylua_ls
+          chmod +x emmylua_check-linux-x64/emmylua_check
+          chmod +x emmylua_doc_cli-linux-x64-glibc.2.17/emmylua_doc_cli
 
           tar -zcvf emmylua_ls-linux-x64.tar.gz -C emmylua_ls-linux-x64 emmylua_ls
           tar -zcvf emmylua_ls-linux-x64-glibc.2.17.tar.gz -C emmylua_ls-linux-x64-glibc.2.17 emmylua_ls
@@ -109,6 +112,8 @@ jobs:
           tar -zcvf emmylua_ls-linux-riscv64.tar.gz -C emmylua_ls-linux-riscv64 emmylua_ls
           tar -zcvf emmylua_ls-darwin-x64.tar.gz -C emmylua_ls-darwin-x64 emmylua_ls
           tar -zcvf emmylua_ls-darwin-arm64.tar.gz -C emmylua_ls-darwin-arm64 emmylua_ls
+          tar -zcvf emmylua_check-linux-x64.tar.gz -C emmylua_check-linux-x64 emmylua_check
+          tar -zcvf emmylua_doc_cli-linux-x64.tar.gz -C emmylua_doc_cli-linux-x64 emmylua_doc_cli
       - name: windows compress
         run: |
           cd emmylua_ls-win32-x64
@@ -134,4 +139,6 @@ jobs:
             emmylua_ls-linux-riscv64.tar.gz
             emmylua_ls-darwin-x64.tar.gz
             emmylua_ls-darwin-arm64.tar.gz
+            emmylua_check-linux-x64.tar.gz
+            emmylua_doc_cli-linux-x64.tar.gz
           token: ${{ secrets.RELEASE }}

crates/emmylua_check/Cargo.toml

@@ -23,7 +23,18 @@ log.workspace = true
 fern.workspace = true
 rowan.workspace = true
 walkdir.workspace = true
-tokio.workspace = true
 tokio-util.workspace = true
-clap.workspace = true
 ansi_term.workspace = true
+tokio.workspace = true
+
+[dependencies.clap]
+workspace = true
+optional = true
+
+[[bin]]
+name = "emmylua_check"
+required-features = ["cli"]
+
+[features]
+default = ["cli"]
+cli = ["dep:clap"]

crates/emmylua_check/src/bin/emmylua_check.rs

@@ -0,0 +1,9 @@
+use clap::Parser;
+use emmylua_check::{cmd_args::CmdArgs, run_check};
+use std::error::Error;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
+    let cmd_args = CmdArgs::parse();
+    run_check(cmd_args).await
+}

crates/emmylua_check/src/cmd_args.rs

@@ -1,41 +1,48 @@
+#[cfg(feature = "cli")]
 use clap::{Parser, ValueEnum};
+
 use std::path::PathBuf;
 
 #[allow(unused)]
-#[derive(Debug, Parser, Clone)]
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "cli", derive(Parser))]
 pub struct CmdArgs {
     /// Configuration file paths.
     /// If not provided, both ".emmyrc.json" and ".luarc.json" will be searched in the workspace
     /// directory
-    #[arg(short, long, value_delimiter = ',')]
+    #[cfg_attr(feature = "cli", arg(short, long, value_delimiter = ','))]
     pub config: Option<Vec<PathBuf>>,
 
     /// Path to the workspace directory
     pub workspace: PathBuf,
 
     /// Comma separated list of ignore patterns.
     /// Patterns must follow glob syntax
-    #[arg(short, long, value_delimiter = ',')]
+    #[cfg_attr(feature = "cli", arg(short, long, value_delimiter = ','))]
     pub ignore: Option<Vec<String>>,
 
     /// Specify output format
-    #[arg(long, default_value = "text", value_enum, ignore_case = true)]
+    #[cfg_attr(
+        feature = "cli",
+        arg(long, default_value = "text", value_enum, ignore_case = true)
+    )]
     pub output_format: OutputFormat,
 
     /// Specify output destination (stdout or a file path, only used when output_format is json).
-    #[arg(long, default_value = "stdout")]
+    #[cfg_attr(feature = "cli", arg(long, default_value = "stdout"))]
     pub output: OutputDestination,
 
     /// Treat warnings as errors
-    #[arg(long)]
+    #[cfg_attr(feature = "cli", arg(long))]
     pub warnings_as_errors: bool,
 
     /// Verbose output
-    #[arg(long)]
+    #[cfg_attr(feature = "cli", arg(long))]
     pub verbose: bool,
 }
 
-#[derive(Debug, Clone, PartialEq, ValueEnum)]
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "cli", derive(ValueEnum))]
 pub enum OutputFormat {
     Json,
     Text,

crates/emmylua_check/src/init.rs

@@ -1,7 +1,8 @@
 use std::{path::PathBuf, str::FromStr, sync::Arc};
 
 use emmylua_code_analysis::{
-    load_configs, load_workspace_files, update_code_style, EmmyLuaAnalysis, Emmyrc, LuaFileInfo,
+    load_configs, load_workspace_files, update_code_style, DbIndex, EmmyLuaAnalysis, Emmyrc,
+    FileId, LuaFileInfo,
 };
 
 fn root_from_configs(config_paths: &Vec<PathBuf>, fallback: &PathBuf) -> PathBuf {
@@ -174,3 +175,15 @@ pub fn calculate_include_and_exclude(
 
     (include, exclude, exclude_dirs)
 }
+
+pub fn get_need_check_ids(db: &DbIndex, files: Vec<FileId>, workspace: &PathBuf) -> Vec<FileId> {
+    let mut need_check_files = Vec::new();
+    for file_id in files {
+        let file_path = db.get_vfs().get_file_path(&file_id).unwrap();
+        if file_path.starts_with(workspace) {
+            need_check_files.push(file_id);
+        }
+    }
+
+    need_check_files
+}

crates/emmylua_check/src/main.rs crates/emmylua_check/src/lib.rscrates/emmylua_check/src/main.rs renamed to crates/emmylua_check/src/lib.rs

@@ -1,20 +1,18 @@
-mod cmd_args;
+pub mod cmd_args;
 mod init;
 mod output;
 mod terminal_display;
 
-use clap::Parser;
-use cmd_args::CmdArgs;
-use emmylua_code_analysis::{DbIndex, FileId};
+pub use cmd_args::*;
 use fern::Dispatch;
 use log::LevelFilter;
 use output::output_result;
-use std::{error::Error, path::PathBuf, sync::Arc};
+use std::{error::Error, sync::Arc};
 use tokio_util::sync::CancellationToken;
 
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
-    let cmd_args = CmdArgs::parse();
+use crate::init::get_need_check_ids;
+
+pub async fn run_check(cmd_args: CmdArgs) -> Result<(), Box<dyn Error + Sync + Send>> {
     let mut workspace = cmd_args.workspace;
     if !workspace.is_absolute() {
         workspace = std::env::current_dir()?.join(workspace);
@@ -54,7 +52,6 @@ async fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
     let analysis = match init::load_workspace(workspace.clone(), cmd_args.config, cmd_args.ignore) {
         Some(analysis) => analysis,
         None => {
-            eprintln!("Failed to load workspace");
             return Err("Failed to load workspace".into());
         }
     };
@@ -94,15 +91,3 @@ async fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
     eprintln!("Check finished");
     Ok(())
 }
-
-fn get_need_check_ids(db: &DbIndex, files: Vec<FileId>, workspace: &PathBuf) -> Vec<FileId> {
-    let mut need_check_files = Vec::new();
-    for file_id in files {
-        let file_path = db.get_vfs().get_file_path(&file_id).unwrap();
-        if file_path.starts_with(workspace) {
-            need_check_files.push(file_id);
-        }
-    }
-
-    need_check_files
-}

crates/emmylua_code_analysis/src/compilation/analyzer/doc/infer_type.rs

@@ -331,23 +331,23 @@ fn infer_binary_type(analyzer: &mut DocAnalyzer, binary_type: &LuaDocBinaryType)
             match op.get_op() {
                 LuaTypeBinaryOperator::Union => match (left_type, right_type) {
                     (LuaType::Union(left_type_union), LuaType::Union(right_type_union)) => {
-                        let mut left_types = left_type_union.into_types();
-                        let right_types = right_type_union.into_types();
-                        left_types.extend(right_types);
-                        return LuaType::Union(LuaUnionType::new(left_types).into());
+                        let mut left_type_set = left_type_union.into_vec();
+                        let right_types = right_type_union.into_vec();
+                        left_type_set.extend(right_types);
+                        return LuaType::Union(LuaUnionType::from_vec(left_type_set).into());
                     }
                     (LuaType::Union(left_type_union), right) => {
-                        let mut left_types = (*left_type_union).into_types();
+                        let mut left_types = (*left_type_union).into_vec();
                         left_types.push(right);
-                        return LuaType::Union(LuaUnionType::new(left_types).into());
+                        return LuaType::Union(LuaUnionType::from_vec(left_types).into());
                     }
                     (left, LuaType::Union(right_type_union)) => {
-                        let mut right_types = (*right_type_union).into_types();
+                        let mut right_types = (*right_type_union).into_vec();
                         right_types.push(left);
-                        return LuaType::Union(LuaUnionType::new(right_types).into());
+                        return LuaType::Union(LuaUnionType::from_vec(right_types).into());
                     }
                     (left, right) => {
-                        return LuaType::Union(LuaUnionType::new(vec![left, right]).into());
+                        return LuaType::Union(LuaUnionType::from_vec(vec![left, right]).into());
                     }
                 },
                 LuaTypeBinaryOperator::Intersection => match (left_type, right_type) {