Merge branch 'master' into simpler-large-char-set-code

Author: maxbrunsfeld

Cargo.lock

@@ -1,9 +1,14 @@
+use std::{
+    collections::BTreeMap,
+    env, fs,
+    path::{Path, PathBuf},
+    str,
+    time::Instant,
+    usize,
+};
+
 use anyhow::Context;
 use lazy_static::lazy_static;
-use std::collections::BTreeMap;
-use std::path::{Path, PathBuf};
-use std::time::Instant;
-use std::{env, fs, str, usize};
 use tree_sitter::{Language, Parser, Query};
 use tree_sitter_loader::{CompileConfig, Loader};
 

cli/benches/benchmark.rs

@@ -1,10 +1,10 @@
 #![doc = include_str!("../README.md")]
 
+use std::{env, fs, path::PathBuf};
+
 use anyhow::{anyhow, Context, Result};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use std::path::PathBuf;
-use std::{env, fs};
 
 /// Holds the contents of tree-sitter's configuration file.
 ///
@@ -62,8 +62,8 @@ impl Config {
     ///
     ///   - Location specified by the path parameter if provided
     ///   - `$TREE_SITTER_DIR/config.json`, if the `TREE_SITTER_DIR` environment variable is set
-    ///   - `tree-sitter/config.json` in your default user configuration directory, as determined
-    ///     by [`dirs::config_dir`](https://docs.rs/dirs/*/dirs/fn.config_dir.html)
+    ///   - `tree-sitter/config.json` in your default user configuration directory, as determined by
+    ///     [`dirs::config_dir`](https://docs.rs/dirs/*/dirs/fn.config_dir.html)
     ///   - `$HOME/.tree-sitter/config.json` as a fallback from where tree-sitter _used_ to store
     ///     its configuration
     pub fn load(path: Option<PathBuf>) -> Result<Self> {

cli/config/src/lib.rs

@@ -26,6 +26,7 @@ once_cell.workspace = true
 regex.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+tempfile.workspace = true
 
 tree-sitter.workspace = true
 tree-sitter-highlight.workspace = true

cli/loader/Cargo.toml

@@ -1 +1 @@
-3.1.37
+3.1.55

cli/loader/emscripten-version

@@ -1,14 +1,18 @@
 #![doc = include_str!("../README.md")]
 
-use std::collections::HashMap;
-use std::ffi::{OsStr, OsString};
-use std::io::{BufRead, BufReader};
-use std::ops::Range;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::sync::Mutex;
-use std::time::SystemTime;
-use std::{env, fs, mem};
+use std::{
+    collections::HashMap,
+    env,
+    ffi::{OsStr, OsString},
+    fs,
+    io::{BufRead, BufReader},
+    mem,
+    ops::Range,
+    path::{Path, PathBuf},
+    process::Command,
+    sync::Mutex,
+    time::SystemTime,
+};
 
 use anyhow::{anyhow, Context, Error, Result};
 use fs4::FileExt;
@@ -126,11 +130,12 @@ pub struct CompileConfig<'a> {
 }
 
 impl<'a> CompileConfig<'a> {
+    #[must_use]
     pub fn new(
         src_path: &'a Path,
         externals: Option<&'a [PathBuf]>,
         output_path: Option<PathBuf>,
-    ) -> CompileConfig<'a> {
+    ) -> Self {
         Self {
             src_path,
             header_paths: vec![src_path],
@@ -445,7 +450,7 @@ impl Loader {
         let parser_path = config.src_path.join("parser.c");
         config.scanner_path = self.get_scanner_path(config.src_path);
 
-        let mut paths_to_check = vec![parser_path.clone()];
+        let mut paths_to_check = vec![parser_path];
 
         if let Some(scanner_path) = config.scanner_path.as_ref() {
             paths_to_check.push(scanner_path.clone());
@@ -484,7 +489,9 @@ impl Loader {
         }
 
         let lock_path = if env::var("CROSS_RUNNER").is_ok() {
-            PathBuf::from("/tmp")
+            tempfile::tempdir()
+                .unwrap()
+                .path()
                 .join("tree-sitter")
                 .join("lock")
                 .join(format!("{}.lock", config.name))
@@ -499,7 +506,8 @@ impl Loader {
         if let Ok(lock_file) = fs::OpenOptions::new().write(true).open(&lock_path) {
             recompile = false;
             if lock_file.try_lock_exclusive().is_err() {
-                // if we can't acquire the lock, another process is compiling the parser, wait for it and don't recompile
+                // if we can't acquire the lock, another process is compiling the parser, wait for
+                // it and don't recompile
                 lock_file.lock_exclusive()?;
                 recompile = false;
             } else {
@@ -1016,7 +1024,7 @@ impl Loader {
                         language_name: grammar_json.name.clone(),
                         scope: config_json.scope,
                         language_id,
-                        file_types: config_json.file_types.unwrap_or(Vec::new()),
+                        file_types: config_json.file_types.unwrap_or_default(),
                         content_regex: Self::regex(config_json.content_regex.as_deref()),
                         first_line_regex: Self::regex(config_json.first_line_regex.as_deref()),
                         injection_regex: Self::regex(config_json.injection_regex.as_deref()),
@@ -1043,8 +1051,11 @@ impl Loader {
                             .push(self.language_configurations.len());
                     }
 
-                    self.language_configurations
-                        .push(unsafe { mem::transmute(configuration) });
+                    self.language_configurations.push(unsafe {
+                        mem::transmute::<LanguageConfiguration<'_>, LanguageConfiguration<'static>>(
+                            configuration,
+                        )
+                    });
 
                     if set_current_path_config
                         && self.language_configuration_in_current_path.is_none()
@@ -1083,8 +1094,11 @@ impl Loader {
                 highlight_names: &self.highlight_names,
                 use_all_highlight_names: self.use_all_highlight_names,
             };
-            self.language_configurations
-                .push(unsafe { mem::transmute(configuration) });
+            self.language_configurations.push(unsafe {
+                mem::transmute::<LanguageConfiguration<'_>, LanguageConfiguration<'static>>(
+                    configuration,
+                )
+            });
             self.languages_by_id
                 .push((parser_path.to_owned(), OnceCell::new(), None));
         }
@@ -1322,8 +1336,7 @@ impl<'a> LanguageConfiguration<'a> {
             .unwrap_or_else(|| ranges.last().unwrap());
         error.offset = offset_within_section - range.start;
         error.row = source[range.start..offset_within_section]
-            .chars()
-            .filter(|c| *c == '\n')
+            .matches(|c| c == '\n')
             .count();
         Error::from(error).context(format!("Error in query file {path:?}"))
     }

cli/loader/src/lib.rs

@@ -40,7 +40,7 @@ const matrix = {
 
 // Determine the URL of the file.
 const platform = matrix.platform[process.platform];
-const arch = platform && platform.arch[process.arch];
+const arch = platform?.arch[process.arch];
 
 if (!platform || !platform.name || !arch || !arch.name) {
   console.error(
@@ -91,7 +91,7 @@ function get(url, callback) {
     }
   };
 
-  const proxyEnv = process.env['HTTPS_PROXY'] || process.env['https_proxy'];
+  const proxyEnv = process.env.HTTPS_PROXY || process.env.https_proxy;
   if (!proxyEnv) {
     https.get(url, processResponse);
     return;

cli/npm/install.js

@@ -1,14 +1,18 @@
+use std::{
+    collections::{hash_map::Entry, HashMap, VecDeque},
+    mem,
+};
+
+use log::info;
+
+use super::{coincident_tokens::CoincidentTokenIndex, token_conflicts::TokenConflictMap};
 use crate::generate::{
-    build_tables::{coincident_tokens::CoincidentTokenIndex, token_conflicts::TokenConflictMap},
     dedup::split_state_id_groups,
     grammars::{LexicalGrammar, SyntaxGrammar},
     nfa::{CharacterSet, NfaCursor},
     rules::{Symbol, TokenSet},
     tables::{AdvanceAction, LexState, LexTable, ParseStateId, ParseTable},
 };
-use log::info;
-use std::collections::{hash_map::Entry, HashMap, VecDeque};
-use std::mem;
 
 pub const LARGE_CHARACTER_RANGE_COUNT: usize = 8;
 

cli/src/generate/build_tables/build_lex_table.rs

@@ -1,25 +1,30 @@
-use super::item::{ParseItem, ParseItemSet, ParseItemSetCore};
-use super::item_set_builder::ParseItemSetBuilder;
-use crate::generate::grammars::PrecedenceEntry;
-use crate::generate::grammars::{
-    InlinedProductionMap, LexicalGrammar, SyntaxGrammar, VariableType,
+use std::{
+    cmp::Ordering,
+    collections::{BTreeMap, HashMap, HashSet, VecDeque},
+    fmt::Write,
+    hash::BuildHasherDefault,
 };
-use crate::generate::node_types::VariableInfo;
-use crate::generate::rules::{Associativity, Precedence, Symbol, SymbolType, TokenSet};
-use crate::generate::tables::{
-    FieldLocation, GotoAction, ParseAction, ParseState, ParseStateId, ParseTable, ParseTableEntry,
-    ProductionInfo, ProductionInfoId,
-};
-use anyhow::{anyhow, Result};
-use std::cmp::Ordering;
-use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
-use std::fmt::Write;
-use std::hash::BuildHasherDefault;
-use std::u32;
 
+use anyhow::{anyhow, Result};
 use indexmap::{map::Entry, IndexMap};
 use rustc_hash::FxHasher;
 
+use super::{
+    item::{ParseItem, ParseItemSet, ParseItemSetCore},
+    item_set_builder::ParseItemSetBuilder,
+};
+use crate::generate::{
+    grammars::{
+        InlinedProductionMap, LexicalGrammar, PrecedenceEntry, SyntaxGrammar, VariableType,
+    },
+    node_types::VariableInfo,
+    rules::{Associativity, Precedence, Symbol, SymbolType, TokenSet},
+    tables::{
+        FieldLocation, GotoAction, ParseAction, ParseState, ParseStateId, ParseTable,
+        ParseTableEntry, ProductionInfo, ProductionInfoId,
+    },
+};
+
 // For conflict reporting, each parse state is associated with an example
 // sequence of symbols that could lead to that parse state.
 type SymbolSequence = Vec<Symbol>;
@@ -293,7 +298,7 @@ impl<'a> ParseTableBuilder<'a> {
                         }
                     }
 
-                    reduction_info.precedence = precedence.clone();
+                    reduction_info.precedence.clone_from(precedence);
                     if let Err(i) = reduction_info.symbols.binary_search(&symbol) {
                         reduction_info.symbols.insert(i, symbol);
                     }
@@ -599,13 +604,13 @@ impl<'a> ParseTableBuilder<'a> {
             write!(&mut msg, "  {}", self.symbol_name(symbol)).unwrap();
         }
 
-        write!(
+        writeln!(
             &mut msg,
-            "  •  {}  …\n\n",
+            "  •  {}  …\n",
             self.symbol_name(&conflicting_lookahead)
         )
         .unwrap();
-        write!(&mut msg, "Possible interpretations:\n\n").unwrap();
+        writeln!(&mut msg, "Possible interpretations:\n").unwrap();
 
         let mut interpretations = conflicting_items
             .iter()
@@ -680,7 +685,7 @@ impl<'a> ParseTableBuilder<'a> {
         }
 
         let mut resolution_count = 0;
-        write!(&mut msg, "\nPossible resolutions:\n\n").unwrap();
+        writeln!(&mut msg, "\nPossible resolutions:\n").unwrap();
         let mut shift_items = Vec::new();
         let mut reduce_items = Vec::new();
         for item in conflicting_items {
@@ -956,7 +961,7 @@ fn populate_following_tokens(
             for entry in result.iter_mut() {
                 entry.insert(*extra);
             }
-            result[extra.index] = all_tokens.clone();
+            result[extra.index].clone_from(&all_tokens);
         }
     }
 }

cli/src/generate/build_tables/build_parse_table.rs

@@ -1,8 +1,11 @@
-use crate::generate::grammars::LexicalGrammar;
-use crate::generate::rules::Symbol;
-use crate::generate::tables::{ParseStateId, ParseTable};
 use std::fmt;
 
+use crate::generate::{
+    grammars::LexicalGrammar,
+    rules::Symbol,
+    tables::{ParseStateId, ParseTable},
+};
+
 pub struct CoincidentTokenIndex<'a> {
     entries: Vec<Vec<ParseStateId>>,
     grammar: &'a LexicalGrammar,