Merge remote-tracking branch 'upstream/main' into not-not-followed-by

.cargo/config.toml

@@ -14,7 +14,5 @@ rustflags = [
 	"-A",
 	"clippy::comparison_chain",
 	"-A",
-	"clippy::needless_return",
-	"-A",
 	"clippy::should_implement_trait",
 ]

.changeset/twelve-pianos-notice.md

@@ -0,0 +1,5 @@
+---
+"@nomicfoundation/slang": minor
+---
+
+Fix NAPI `cursor` types and expose `cursor.depth`.

.cspell.json

@@ -13,6 +13,7 @@
     "inheritdoc",
     "ipfs",
     "mkdocs",
+    "napi",
     "nomic",
     "nomicfoundation",
     "struct",

.vscode/settings.json

@@ -22,7 +22,7 @@
     "**/Pipfile.lock": true
   },
   "triggerTaskOnSave.tasks": {
-    "Run Rust Analyzer Checks": ["**/*.rs.jinja2"],
+    "Run Rust Analyzer Checks": ["**/*.jinja2"],
     "Validate Solidity Definition": ["crates/solidity/inputs/language/definition/**/*.yml"]
   },
   "typescript.tsdk": "node_modules/typescript/lib",

README.md

@@ -17,7 +17,7 @@ Written in Rust and distributed in multiple languages.
 
 This repository maintains the source code and release process for these projects:
 
--   [Slang Rust Crate + CLI](https://nomicfoundation.github.io/slang/user-guide/cargo-crate/)
+-   [Slang Rust Crate + CLI](https://nomicfoundation.github.io/slang/user-guide/rust-crate/)
 -   [Slang TypeScript Package](https://nomicfoundation.github.io/slang/user-guide/npm-package/)
 -   [Solidity Language Specification](https://nomicfoundation.github.io/slang/solidity-specification/)
 

crates/codegen/ebnf/src/nodes.rs

@@ -123,7 +123,7 @@ impl EbnfNode {
     pub fn precedence(&self) -> u8 {
         // We are specifying precedence "groups" instead of a flat list.
         // This separates members of the same precedence, like both "a b (c | d)" and "a | b | (c d)".
-        return match self {
+        match self {
             // Not an operator
             EbnfNode::WithComment { .. } => 0,
 
@@ -142,6 +142,6 @@ impl EbnfNode {
             EbnfNode::ProductionRef { .. } | EbnfNode::Range { .. } | EbnfNode::Terminal { .. } => {
                 4
             }
-        };
+        }
     }
 }

crates/codegen/ebnf/src/parser.rs

@@ -13,50 +13,36 @@ impl EbnfNode {
                 open,
                 parser,
                 close,
-            } => {
-                return Self::sequence(vec![
-                    Self::production_ref(&open.reference),
-                    Self::from_parser(parser),
-                    Self::production_ref(&close.reference),
-                ]);
-            }
+            } => Self::sequence(vec![
+                Self::production_ref(&open.reference),
+                Self::from_parser(parser),
+                Self::production_ref(&close.reference),
+            ]),
 
-            ParserDefinition::OneOrMore(parser) => {
-                return Self::one_or_more(Self::from_parser(parser));
-            }
+            ParserDefinition::OneOrMore(parser) => Self::one_or_more(Self::from_parser(parser)),
 
-            ParserDefinition::Optional(parser) => {
-                return Self::optional(Self::from_parser(parser));
-            }
+            ParserDefinition::Optional(parser) => Self::optional(Self::from_parser(parser)),
 
-            ParserDefinition::Reference(name) => {
-                return Self::production_ref(name);
-            }
+            ParserDefinition::Reference(name) => Self::production_ref(name),
 
-            ParserDefinition::SeparatedBy { parser, separator } => {
-                return Self::sequence(vec![
+            ParserDefinition::SeparatedBy { parser, separator } => Self::sequence(vec![
+                Self::from_parser(parser),
+                Self::zero_or_more(Self::sequence(vec![
+                    Self::production_ref(&separator.reference),
                     Self::from_parser(parser),
-                    Self::zero_or_more(Self::sequence(vec![
-                        Self::production_ref(&separator.reference),
-                        Self::from_parser(parser),
-                    ])),
-                ]);
-            }
+                ])),
+            ]),
 
             ParserDefinition::Sequence(parsers) => {
                 return Self::sequence(parsers.iter().map(Self::from_parser).collect());
             }
 
-            ParserDefinition::TerminatedBy { parser, terminator } => {
-                return Self::sequence(vec![
-                    Self::from_parser(parser),
-                    Self::production_ref(&terminator.reference),
-                ]);
-            }
+            ParserDefinition::TerminatedBy { parser, terminator } => Self::sequence(vec![
+                Self::from_parser(parser),
+                Self::production_ref(&terminator.reference),
+            ]),
 
-            ParserDefinition::ZeroOrMore(parser) => {
-                return Self::zero_or_more(Self::from_parser(parser));
-            }
-        };
+            ParserDefinition::ZeroOrMore(parser) => Self::zero_or_more(Self::from_parser(parser)),
+        }
     }
 }

crates/codegen/ebnf/src/precedence_parser.rs

@@ -69,6 +69,6 @@ impl EbnfNode {
 
         choices.push(Self::from_parser(&precedence_parser.primary_expression));
 
-        return Self::choice(choices);
+        Self::choice(choices)
     }
 }

crates/codegen/ebnf/src/scanner.rs

@@ -12,48 +12,29 @@ impl EbnfNode {
             ScannerDefinition::Difference {
                 minuend,
                 subtrahend,
-            } => {
-                return Self::difference(
-                    Self::from_scanner(minuend),
-                    Self::from_scanner(subtrahend),
-                );
-            }
+            } => Self::difference(Self::from_scanner(minuend), Self::from_scanner(subtrahend)),
 
-            ScannerDefinition::Not(scanner) => {
-                return Self::not(Self::from_scanner(scanner));
-            }
+            ScannerDefinition::Not(scanner) => Self::not(Self::from_scanner(scanner)),
 
-            ScannerDefinition::OneOrMore(scanner) => {
-                return Self::one_or_more(Self::from_scanner(scanner));
-            }
+            ScannerDefinition::OneOrMore(scanner) => Self::one_or_more(Self::from_scanner(scanner)),
 
-            ScannerDefinition::Optional(scanner) => {
-                return Self::optional(Self::from_scanner(scanner));
-            }
+            ScannerDefinition::Optional(scanner) => Self::optional(Self::from_scanner(scanner)),
 
-            ScannerDefinition::Range { from, to } => {
-                return Self::range(*from, *to);
-            }
+            ScannerDefinition::Range { from, to } => Self::range(*from, *to),
 
-            ScannerDefinition::Reference(name) => {
-                return Self::production_ref(name);
-            }
+            ScannerDefinition::Reference(name) => Self::production_ref(name),
 
             ScannerDefinition::Sequence(scanners) => {
                 return Self::sequence(scanners.iter().map(Self::from_scanner).collect());
             }
 
-            ScannerDefinition::Terminal(terminal) => {
-                return Self::terminal(terminal);
-            }
+            ScannerDefinition::Terminal(terminal) => Self::terminal(terminal),
 
-            ScannerDefinition::TrailingContext { scanner, .. } => {
-                return Self::from_scanner(scanner);
-            }
+            ScannerDefinition::TrailingContext { scanner, .. } => Self::from_scanner(scanner),
 
             ScannerDefinition::ZeroOrMore(scanner) => {
-                return Self::zero_or_more(Self::from_scanner(scanner));
+                Self::zero_or_more(Self::from_scanner(scanner))
             }
-        };
+        }
     }
 }

crates/codegen/ebnf/src/serialization.rs

@@ -55,7 +55,7 @@ impl EbnfSerializer {
 
         instance.serialize_statement(&production.name, &root_node);
 
-        return Some(instance.outputs);
+        Some(instance.outputs)
     }
 
     /// Serializes a single EBNF statement.
@@ -105,7 +105,7 @@ impl EbnfSerializer {
             .map(|choice| {
                 let mut buffer = String::new();
                 self.serialize_node(choice, &mut buffer);
-                return buffer;
+                buffer
             })
             .collect::<Vec<_>>();
 
@@ -120,7 +120,7 @@ impl EbnfSerializer {
         }
 
         // Otherwise, break into multiple lines:
-        return choices.join(&format!("\n{padding} | ", padding = " ".repeat(name_width)));
+        choices.join(&format!("\n{padding} | ", padding = " ".repeat(name_width)))
     }
 
     /// Serialize and append an EBNF node to the buffer.
@@ -219,7 +219,7 @@ impl EbnfSerializer {
             name = format!("«{name}»");
         }
 
-        return name;
+        name
     }
 }
 
@@ -247,5 +247,5 @@ fn format_string_literal(value: &str) -> String {
         })
         .collect();
 
-    return format!("{delimiter}{formatted}{delimiter}");
+    format!("{delimiter}{formatted}{delimiter}")
 }

crates/codegen/language/definition/src/compiler/analysis/definitions.rs

@@ -157,7 +157,7 @@ fn calculate_defined_in(analysis: &mut Analysis, item: &SpannedItem) -> VersionS
         }
     };
 
-    return defined_in;
+    defined_in
 }
 
 #[allow(clippy::enum_variant_names)]

crates/codegen/language/definition/src/compiler/analysis/mod.rs

@@ -64,7 +64,7 @@ impl Analysis {
 
         analyze_reachability(&mut analysis);
 
-        return analysis;
+        analysis
     }
 }
 

crates/codegen/language/definition/src/compiler/analysis/references.rs

@@ -403,9 +403,7 @@ enum ReferenceFilter {
 impl ReferenceFilter {
     fn apply(&self, item: &SpannedItem) -> bool {
         match (self, item) {
-            (Self::Nodes, item) => {
-                return Self::NonTerminals.apply(item) || Self::Terminals.apply(item);
-            }
+            (Self::Nodes, item) => Self::NonTerminals.apply(item) || Self::Terminals.apply(item),
             (
                 Self::NonTerminals,
                 SpannedItem::Struct { .. }
@@ -422,14 +420,10 @@ impl ReferenceFilter {
             )
             | (Self::Trivia, SpannedItem::Trivia { .. })
             | (Self::Tokens, SpannedItem::Token { .. })
-            | (Self::Fragments, SpannedItem::Fragment { .. }) => {
-                return true;
-            }
+            | (Self::Fragments, SpannedItem::Fragment { .. }) => true,
 
-            _ => {
-                return false;
-            }
-        };
+            _ => false,
+        }
     }
 }
 
@@ -499,20 +493,14 @@ fn update_enablement(
             .add(new_specifier, &Errors::EnabledTooWide(existing_enablement));
     }
 
-    return new_enablement;
+    new_enablement
 }
 
 fn check_version_specifier(analysis: &mut Analysis, specifier: &SpannedVersionSpecifier) -> bool {
     match specifier {
-        SpannedVersionSpecifier::Never => {
-            return true;
-        }
-        SpannedVersionSpecifier::From { from } => {
-            return check_version(analysis, from);
-        }
-        SpannedVersionSpecifier::Till { till } => {
-            return check_version(analysis, till);
-        }
+        SpannedVersionSpecifier::Never => true,
+        SpannedVersionSpecifier::From { from } => check_version(analysis, from),
+        SpannedVersionSpecifier::Till { till } => check_version(analysis, till),
         SpannedVersionSpecifier::Range { from, till } => {
             if from >= till {
                 analysis
@@ -521,9 +509,9 @@ fn check_version_specifier(analysis: &mut Analysis, specifier: &SpannedVersionSp
                 return false;
             }
 
-            return check_version(analysis, from) || check_version(analysis, till);
+            check_version(analysis, from) || check_version(analysis, till)
         }
-    };
+    }
 }
 
 fn check_version(analysis: &mut Analysis, version: &Spanned<Version>) -> bool {
@@ -535,7 +523,7 @@ fn check_version(analysis: &mut Analysis, version: &Spanned<Version>) -> bool {
         return false;
     }
 
-    return true;
+    true
 }
 
 #[derive(thiserror::Error, Debug)]

crates/codegen/language/definition/src/compiler/emitter.rs

@@ -17,7 +17,7 @@ impl LanguageEmitter {
 
         let intellisense_types = Self::emit_intellisense_types(analysis);
 
-        return quote! {
+        quote! {
             mod #container_mod {
                 // Main entry-point to create language definitions:
                 pub struct #definition_struct;
@@ -36,7 +36,7 @@ impl LanguageEmitter {
                     #intellisense_types
                 }
             }
-        };
+        }
     }
 
     fn emit_intellisense_types(analysis: &Analysis) -> TokenStream {
@@ -66,6 +66,6 @@ impl LanguageEmitter {
             }
         }
 
-        return result;
+        result
     }
 }

crates/codegen/language/definition/src/compiler/mod.rs

@@ -21,8 +21,6 @@ impl LanguageCompiler {
 
         let analysis = Analysis::analyze(parse_output);
 
-        let output = LanguageEmitter::emit(&analysis);
-
-        return output;
+        LanguageEmitter::emit(&analysis)
     }
 }