From 893a63196c5dc997abc60bb9b2c3f5dbce2a164b Mon Sep 17 00:00:00 2001 From: Omar Tawfik <15987992+OmarTawfik@users.noreply.github.com> Date: Tue, 31 Dec 2024 02:32:54 -0800 Subject: [PATCH 1/4] add generated `language-definition.json` (#1206) cc @AntonyBlakey --- Cargo.lock | 1 + .../parse_input_tokens/external_types.rs | 5 +- .../definition/src/model/built_ins.rs | 14 + .../language/definition/src/model/manifest.rs | 3 +- .../src/model/nonterminals/enum_.rs | 2 + .../src/model/nonterminals/field.rs | 6 + .../src/model/nonterminals/precedence.rs | 5 + .../src/model/nonterminals/repeated.rs | 2 + .../src/model/nonterminals/separated.rs | 2 + .../src/model/nonterminals/struct_.rs | 3 + .../src/model/terminals/fragment.rs | 1 + .../definition/src/model/terminals/keyword.rs | 6 +- .../definition/src/model/terminals/token.rs | 1 + .../language/tests/src/pass/tiny_language.rs | 8 +- .../runtime/generator/src/bindings/mod.rs | 6 +- crates/codegen/spec/Cargo.toml | 1 + .../codegen/spec/src/generators/topic_page.rs | 2 +- crates/codegen/spec/src/lib.rs | 9 +- .../spec/generated/language-definition.json | 9864 +++++++++++++++++ 19 files changed, 9926 insertions(+), 15 deletions(-) create mode 100644 crates/solidity/outputs/spec/generated/language-definition.json diff --git a/Cargo.lock b/Cargo.lock index a5a2c96c1c..f0414f1d46 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -517,6 +517,7 @@ dependencies = [ "infra_utils", "itertools 0.13.0", "serde", + "serde_json", ] [[package]] diff --git a/crates/codegen/language/definition/src/internals/parse_input_tokens/external_types.rs b/crates/codegen/language/definition/src/internals/parse_input_tokens/external_types.rs index 6f9a17d844..5d6035ca6e 100644 --- a/crates/codegen/language/definition/src/internals/parse_input_tokens/external_types.rs +++ b/crates/codegen/language/definition/src/internals/parse_input_tokens/external_types.rs @@ -1,9 +1,8 @@ use std::fmt::Debug; -use std::path::{Path, PathBuf}; +use std::path::PathBuf; use std::rc::Rc; use indexmap::{IndexMap, IndexSet}; -use infra_utils::paths::PathExtensions; use proc_macro2::Ident; use semver::Version; use syn::parse::ParseStream; @@ -100,7 +99,7 @@ impl ParseInputTokens for PathBuf { fn parse_value(input: ParseStream<'_>, errors: &mut ErrorsCollection) -> Result { let value = String::parse_value(input, errors)?; - Ok(Path::repo_path(value)) + Ok(PathBuf::from(value)) } } diff --git a/crates/codegen/language/definition/src/model/built_ins.rs b/crates/codegen/language/definition/src/model/built_ins.rs index 741b88b390..6982161b1a 100644 --- a/crates/codegen/language/definition/src/model/built_ins.rs +++ b/crates/codegen/language/definition/src/model/built_ins.rs @@ -18,8 +18,14 @@ pub enum BuiltIn { #[derive_spanned_type(Clone, Debug, ParseInputTokens, WriteOutputTokens)] pub struct BuiltInFunction { pub name: String, + + #[serde(skip_serializing_if = "Vec::is_empty")] pub parameters: Vec, + + #[serde(skip_serializing_if = "Option::is_none")] pub return_type: Option, + + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, } @@ -27,8 +33,14 @@ pub struct BuiltInFunction { #[derive_spanned_type(Clone, Debug, ParseInputTokens, WriteOutputTokens)] pub struct BuiltInType { pub name: String, + + #[serde(skip_serializing_if = "Vec::is_empty")] pub fields: Vec, + + #[serde(skip_serializing_if = "Vec::is_empty")] pub functions: Vec, + + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, } @@ -36,5 +48,7 @@ pub struct BuiltInType { #[derive_spanned_type(Clone, Debug, ParseInputTokens, WriteOutputTokens)] pub struct BuiltInField { pub definition: String, + + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, } diff --git a/crates/codegen/language/definition/src/model/manifest.rs b/crates/codegen/language/definition/src/model/manifest.rs index cfe1ef7c82..2f19c3fb17 100644 --- a/crates/codegen/language/definition/src/model/manifest.rs +++ b/crates/codegen/language/definition/src/model/manifest.rs @@ -167,7 +167,8 @@ impl Section { #[derive_spanned_type(Clone, Debug, ParseInputTokens, WriteOutputTokens)] pub struct Topic { pub title: String, - pub notes_file: Option, + + #[serde(skip_serializing_if = "Option::is_none")] pub lexical_context: Option, pub items: Vec, diff --git a/crates/codegen/language/definition/src/model/nonterminals/enum_.rs b/crates/codegen/language/definition/src/model/nonterminals/enum_.rs index 28a0c64e9b..02654bf9f0 100644 --- a/crates/codegen/language/definition/src/model/nonterminals/enum_.rs +++ b/crates/codegen/language/definition/src/model/nonterminals/enum_.rs @@ -8,6 +8,7 @@ use crate::model::{Identifier, VersionSpecifier}; pub struct EnumItem { pub name: Identifier, + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, pub variants: Vec, @@ -18,5 +19,6 @@ pub struct EnumItem { pub struct EnumVariant { pub reference: Identifier, + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, } diff --git a/crates/codegen/language/definition/src/model/nonterminals/field.rs b/crates/codegen/language/definition/src/model/nonterminals/field.rs index acb05bfc38..e7abe74b7c 100644 --- a/crates/codegen/language/definition/src/model/nonterminals/field.rs +++ b/crates/codegen/language/definition/src/model/nonterminals/field.rs @@ -6,7 +6,10 @@ use crate::model::{Identifier, VersionSpecifier}; #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] #[derive_spanned_type(Clone, Debug, ParseInputTokens, WriteOutputTokens)] pub struct FieldsErrorRecovery { + #[serde(skip_serializing_if = "Option::is_none")] pub terminator: Option, + + #[serde(skip_serializing_if = "Option::is_none")] pub delimiters: Option, } @@ -15,12 +18,14 @@ pub struct FieldsErrorRecovery { pub struct FieldDelimiters { pub open: Identifier, pub close: Identifier, + /// How many tokens have to be matched to trigger the error recovery. /// For ambiguous syntaxes this needs to be set to at least N, where N /// is the token lookahead required to disambiguate the syntax. /// /// By default, we assume no lookahead (0) is required to recover from /// unrecognized body between delimiters, so it's always triggered. + #[serde(skip_serializing_if = "Option::is_none")] pub terminals_matched_acceptance_threshold: Option, } @@ -33,6 +38,7 @@ pub enum Field { Optional { reference: Identifier, + #[serde(skip_serializing_if = "Option::is_none")] enabled: Option, }, } diff --git a/crates/codegen/language/definition/src/model/nonterminals/precedence.rs b/crates/codegen/language/definition/src/model/nonterminals/precedence.rs index 5e4f9b4eb8..cd3cbe3ca2 100644 --- a/crates/codegen/language/definition/src/model/nonterminals/precedence.rs +++ b/crates/codegen/language/definition/src/model/nonterminals/precedence.rs @@ -11,6 +11,7 @@ use crate::model::{Field, FieldsErrorRecovery, Identifier, VersionSpecifier}; pub struct PrecedenceItem { pub name: Identifier, + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, pub precedence_expressions: Vec>, @@ -30,9 +31,12 @@ pub struct PrecedenceExpression { pub struct PrecedenceOperator { pub model: OperatorModel, + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, + #[serde(skip_serializing_if = "Option::is_none")] pub error_recovery: Option, + pub fields: IndexMap, } @@ -50,5 +54,6 @@ pub enum OperatorModel { pub struct PrimaryExpression { pub reference: Identifier, + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, } diff --git a/crates/codegen/language/definition/src/model/nonterminals/repeated.rs b/crates/codegen/language/definition/src/model/nonterminals/repeated.rs index b8653d0a9b..4b07fdf593 100644 --- a/crates/codegen/language/definition/src/model/nonterminals/repeated.rs +++ b/crates/codegen/language/definition/src/model/nonterminals/repeated.rs @@ -9,7 +9,9 @@ pub struct RepeatedItem { pub name: Identifier, pub reference: Identifier, + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, + #[serde(skip_serializing_if = "Option::is_none")] pub allow_empty: Option, } diff --git a/crates/codegen/language/definition/src/model/nonterminals/separated.rs b/crates/codegen/language/definition/src/model/nonterminals/separated.rs index b91ec324c8..dc042198f1 100644 --- a/crates/codegen/language/definition/src/model/nonterminals/separated.rs +++ b/crates/codegen/language/definition/src/model/nonterminals/separated.rs @@ -10,7 +10,9 @@ pub struct SeparatedItem { pub reference: Identifier, pub separator: Identifier, + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, + #[serde(skip_serializing_if = "Option::is_none")] pub allow_empty: Option, } diff --git a/crates/codegen/language/definition/src/model/nonterminals/struct_.rs b/crates/codegen/language/definition/src/model/nonterminals/struct_.rs index 2fabf7af69..3b7a8ba3aa 100644 --- a/crates/codegen/language/definition/src/model/nonterminals/struct_.rs +++ b/crates/codegen/language/definition/src/model/nonterminals/struct_.rs @@ -9,8 +9,11 @@ use crate::model::{Field, FieldsErrorRecovery, Identifier, VersionSpecifier}; pub struct StructItem { pub name: Identifier, + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, + #[serde(skip_serializing_if = "Option::is_none")] pub error_recovery: Option, + pub fields: IndexMap, } diff --git a/crates/codegen/language/definition/src/model/terminals/fragment.rs b/crates/codegen/language/definition/src/model/terminals/fragment.rs index 585cccc12e..6e6fe897fc 100644 --- a/crates/codegen/language/definition/src/model/terminals/fragment.rs +++ b/crates/codegen/language/definition/src/model/terminals/fragment.rs @@ -8,6 +8,7 @@ use crate::model::{Identifier, Scanner, VersionSpecifier}; pub struct FragmentItem { pub name: Identifier, + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, pub scanner: Scanner, diff --git a/crates/codegen/language/definition/src/model/terminals/keyword.rs b/crates/codegen/language/definition/src/model/terminals/keyword.rs index eeff982fc1..2222734463 100644 --- a/crates/codegen/language/definition/src/model/terminals/keyword.rs +++ b/crates/codegen/language/definition/src/model/terminals/keyword.rs @@ -16,10 +16,14 @@ pub struct KeywordItem { #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] #[derive_spanned_type(Clone, Debug, ParseInputTokens, WriteOutputTokens)] pub struct KeywordDefinition { + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, + /// When the keyword is reserved, i.e. can't be used in other position (e.g. as a name) + #[serde(skip_serializing_if = "Option::is_none")] pub reserved: Option, - // Underlying keyword scanner (i.e. identifier scanner) + + /// Underlying keyword scanner (i.e. identifier scanner) pub value: KeywordValue, } diff --git a/crates/codegen/language/definition/src/model/terminals/token.rs b/crates/codegen/language/definition/src/model/terminals/token.rs index 9f39455f4f..2ea24450eb 100644 --- a/crates/codegen/language/definition/src/model/terminals/token.rs +++ b/crates/codegen/language/definition/src/model/terminals/token.rs @@ -14,6 +14,7 @@ pub struct TokenItem { #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] #[derive_spanned_type(Clone, Debug, ParseInputTokens, WriteOutputTokens)] pub struct TokenDefinition { + #[serde(skip_serializing_if = "Option::is_none")] pub enabled: Option, pub scanner: Scanner, diff --git a/crates/codegen/language/tests/src/pass/tiny_language.rs b/crates/codegen/language/tests/src/pass/tiny_language.rs index 6b5652634a..cc9efb0d69 100644 --- a/crates/codegen/language/tests/src/pass/tiny_language.rs +++ b/crates/codegen/language/tests/src/pass/tiny_language.rs @@ -1,10 +1,7 @@ -use std::path::Path; - use codegen_language_definition::model::{ Field, Item, Language, Scanner, Section, StructItem, TokenDefinition, TokenItem, Topic, TriviaParser, }; -use infra_utils::paths::PathExtensions; use semver::Version; codegen_language_macros::compile!(Language( @@ -49,8 +46,8 @@ fn definition() { tiny::TinyDefinition::create(), Language { name: "Tiny".into(), - documentation_dir: Path::repo_path("tiny/docs"), - binding_rules_file: Path::repo_path("tiny/bindings/rules.msgb"), + documentation_dir: "tiny/docs".into(), + binding_rules_file: "tiny/bindings/rules.msgb".into(), file_extension: Some(".tiny".into()), root_item: "Foo".into(), leading_trivia: TriviaParser::Sequence { parsers: [].into() }, @@ -65,7 +62,6 @@ fn definition() { title: "Section One".into(), topics: vec![Topic { title: "Topic One".into(), - notes_file: None, lexical_context: None, items: [ Item::Struct { diff --git a/crates/codegen/runtime/generator/src/bindings/mod.rs b/crates/codegen/runtime/generator/src/bindings/mod.rs index 61e9f5687e..4017560cf6 100644 --- a/crates/codegen/runtime/generator/src/bindings/mod.rs +++ b/crates/codegen/runtime/generator/src/bindings/mod.rs @@ -1,4 +1,5 @@ use std::collections::BTreeSet; +use std::path::Path; use anyhow::Result; use codegen_language_definition::model; @@ -17,9 +18,10 @@ pub struct BindingsModel { impl BindingsModel { pub fn from_language(language: &model::Language) -> Result { // We use `CodegenFileSystem` here to ensure the rules are rebuilt if the rules file changes - let binding_rules_dir = language.binding_rules_file.unwrap_parent(); + let binding_rules_file = Path::repo_path(&language.binding_rules_file); + let binding_rules_dir = binding_rules_file.unwrap_parent(); let mut fs = CodegenFileSystem::new(binding_rules_dir)?; - let binding_rules_source = fs.read_file(&language.binding_rules_file)?; + let binding_rules_source = fs.read_file(&binding_rules_file)?; let built_ins_versions = language.collect_built_ins_versions(); let file_extension = language.file_extension.clone().unwrap_or_default(); diff --git a/crates/codegen/spec/Cargo.toml b/crates/codegen/spec/Cargo.toml index 833912f2d0..0753ebb039 100644 --- a/crates/codegen/spec/Cargo.toml +++ b/crates/codegen/spec/Cargo.toml @@ -14,6 +14,7 @@ Inflector = { workspace = true } infra_utils = { workspace = true } itertools = { workspace = true } serde = { workspace = true } +serde_json = { workspace = true } [lints] workspace = true diff --git a/crates/codegen/spec/src/generators/topic_page.rs b/crates/codegen/spec/src/generators/topic_page.rs index ff939be0a3..26ff17c5f1 100644 --- a/crates/codegen/spec/src/generators/topic_page.rs +++ b/crates/codegen/spec/src/generators/topic_page.rs @@ -53,7 +53,7 @@ pub fn generate_topic_page( } } - let documentation_dir = model.language.documentation_dir.strip_repo_root()?; + let documentation_dir = &model.language.documentation_dir; writeln!(buffer)?; writeln!( diff --git a/crates/codegen/spec/src/lib.rs b/crates/codegen/spec/src/lib.rs index 85ca47da4d..1e1f29df5d 100644 --- a/crates/codegen/spec/src/lib.rs +++ b/crates/codegen/spec/src/lib.rs @@ -15,6 +15,7 @@ use std::rc::Rc; use anyhow::Result; use codegen_language_definition::model::Language; use infra_utils::codegen::CodegenFileSystem; +use infra_utils::paths::PathExtensions; use crate::generators::grammar_ebnf::generate_grammar_ebnf; use crate::generators::navigation::{SpecDir, SpecPage}; @@ -26,7 +27,13 @@ pub struct Spec; impl Spec { pub fn generate(language: Rc, output_dir: &Path) -> Result<()> { - let mut fs = CodegenFileSystem::new(&language.documentation_dir)?; + let documentation_dir = Path::repo_path(&language.documentation_dir); + let mut fs = CodegenFileSystem::new(documentation_dir)?; + + fs.write_file( + output_dir.join("language-definition.json"), + serde_json::to_string(&language)?, + )?; let model = SpecModel::build(language); let public_dir = Self::generate_public_dir(&model)?; diff --git a/crates/solidity/outputs/spec/generated/language-definition.json b/crates/solidity/outputs/spec/generated/language-definition.json new file mode 100644 index 0000000000..3779457f4e --- /dev/null +++ b/crates/solidity/outputs/spec/generated/language-definition.json @@ -0,0 +1,9864 @@ +{ + "name": "Solidity", + "documentation_dir": "crates/solidity/inputs/language/docs", + "binding_rules_file": "crates/solidity/inputs/language/bindings/rules.msgb", + "file_extension": ".sol", + "root_item": "SourceUnit", + "leading_trivia": { + "OneOrMore": { + "parser": { + "Choice": { + "parsers": [ + { "Trivia": { "reference": "Whitespace" } }, + { "Trivia": { "reference": "EndOfLine" } }, + { "Trivia": { "reference": "SingleLineComment" } }, + { "Trivia": { "reference": "MultiLineComment" } }, + { "Trivia": { "reference": "SingleLineNatSpecComment" } }, + { "Trivia": { "reference": "MultiLineNatSpecComment" } } + ] + } + } + } + }, + "trailing_trivia": { + "Sequence": { + "parsers": [ + { "Optional": { "parser": { "Trivia": { "reference": "Whitespace" } } } }, + { "Optional": { "parser": { "Trivia": { "reference": "SingleLineComment" } } } }, + { "Trivia": { "reference": "EndOfLine" } } + ] + } + }, + "versions": [ + "0.4.11", + "0.4.12", + "0.4.13", + "0.4.14", + "0.4.15", + "0.4.16", + "0.4.17", + "0.4.18", + "0.4.19", + "0.4.20", + "0.4.21", + "0.4.22", + "0.4.23", + "0.4.24", + "0.4.25", + "0.4.26", + "0.5.0", + "0.5.1", + "0.5.2", + "0.5.3", + "0.5.4", + "0.5.5", + "0.5.6", + "0.5.7", + "0.5.8", + "0.5.9", + "0.5.10", + "0.5.11", + "0.5.12", + "0.5.13", + "0.5.14", + "0.5.15", + "0.5.16", + "0.5.17", + "0.6.0", + "0.6.1", + "0.6.2", + "0.6.3", + "0.6.4", + "0.6.5", + "0.6.6", + "0.6.7", + "0.6.8", + "0.6.9", + "0.6.10", + "0.6.11", + "0.6.12", + "0.7.0", + "0.7.1", + "0.7.2", + "0.7.3", + "0.7.4", + "0.7.5", + "0.7.6", + "0.8.0", + "0.8.1", + "0.8.2", + "0.8.3", + "0.8.4", + "0.8.5", + "0.8.6", + "0.8.7", + "0.8.8", + "0.8.9", + "0.8.10", + "0.8.11", + "0.8.12", + "0.8.13", + "0.8.14", + "0.8.15", + "0.8.16", + "0.8.17", + "0.8.18", + "0.8.19", + "0.8.20", + "0.8.21", + "0.8.22", + "0.8.23", + "0.8.24", + "0.8.25", + "0.8.26", + "0.8.27", + "0.8.28" + ], + "sections": [ + { + "title": "File Structure", + "topics": [ + { "title": "License Specifiers", "items": [] }, + { + "title": "Source Unit", + "items": [ + { + "Struct": { + "item": { + "name": "SourceUnit", + "fields": { "members": { "Required": { "reference": "SourceUnitMembers" } } } + } + } + }, + { + "Repeated": { + "item": { "name": "SourceUnitMembers", "reference": "SourceUnitMember", "allow_empty": true } + } + }, + { + "Enum": { + "item": { + "name": "SourceUnitMember", + "variants": [ + { "reference": "PragmaDirective" }, + { "reference": "ImportDirective" }, + { "reference": "ContractDefinition" }, + { "reference": "InterfaceDefinition" }, + { "reference": "LibraryDefinition" }, + { "reference": "StructDefinition", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "EnumDefinition", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "FunctionDefinition", "enabled": { "From": { "from": "0.7.1" } } }, + { "reference": "ErrorDefinition", "enabled": { "From": { "from": "0.8.4" } } }, + { "reference": "UserDefinedValueTypeDefinition", "enabled": { "From": { "from": "0.8.8" } } }, + { "reference": "UsingDirective", "enabled": { "From": { "from": "0.8.13" } } }, + { "reference": "EventDefinition", "enabled": { "From": { "from": "0.8.22" } } }, + { "reference": "ConstantDefinition", "enabled": { "From": { "from": "0.7.4" } } } + ] + } + } + } + ] + }, + { + "title": "Pragma Directives", + "lexical_context": "Pragma", + "items": [ + { + "Struct": { + "item": { + "name": "PragmaDirective", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "pragma_keyword": { "Required": { "reference": "PragmaKeyword" } }, + "pragma": { "Required": { "reference": "Pragma" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "Pragma", + "variants": [ + { "reference": "AbicoderPragma" }, + { "reference": "ExperimentalPragma" }, + { "reference": "VersionPragma" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "AbicoderPragma", + "fields": { + "abicoder_keyword": { "Required": { "reference": "AbicoderKeyword" } }, + "version": { "Required": { "reference": "Identifier" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ExperimentalPragma", + "fields": { + "experimental_keyword": { "Required": { "reference": "ExperimentalKeyword" } }, + "feature": { "Required": { "reference": "ExperimentalFeature" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "ExperimentalFeature", + "variants": [{ "reference": "Identifier" }, { "reference": "StringLiteral" }] + } + } + }, + { + "Struct": { + "item": { + "name": "VersionPragma", + "fields": { + "solidity_keyword": { "Required": { "reference": "SolidityKeyword" } }, + "sets": { "Required": { "reference": "VersionExpressionSets" } } + } + } + } + }, + { + "Separated": { + "item": { "name": "VersionExpressionSets", "reference": "VersionExpressionSet", "separator": "BarBar" } + } + }, + { "Repeated": { "item": { "name": "VersionExpressionSet", "reference": "VersionExpression" } } }, + { + "Enum": { + "item": { + "name": "VersionExpression", + "variants": [{ "reference": "VersionRange" }, { "reference": "VersionTerm" }] + } + } + }, + { + "Struct": { + "item": { + "name": "VersionRange", + "fields": { + "start": { "Required": { "reference": "VersionLiteral" } }, + "minus": { "Required": { "reference": "Minus" } }, + "end": { "Required": { "reference": "VersionLiteral" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "VersionTerm", + "fields": { + "operator": { "Optional": { "reference": "VersionOperator" } }, + "literal": { "Required": { "reference": "VersionLiteral" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "VersionOperator", + "variants": [ + { "reference": "Caret" }, + { "reference": "Tilde" }, + { "reference": "Equal" }, + { "reference": "LessThan" }, + { "reference": "GreaterThan" }, + { "reference": "LessThanEqual" }, + { "reference": "GreaterThanEqual" } + ] + } + } + }, + { + "Enum": { + "item": { + "name": "VersionLiteral", + "variants": [ + { "reference": "SimpleVersionLiteral" }, + { "reference": "SingleQuotedVersionLiteral" }, + { "reference": "DoubleQuotedVersionLiteral" } + ] + } + } + }, + { + "Separated": { + "item": { "name": "SimpleVersionLiteral", "reference": "VersionSpecifier", "separator": "Period" } + } + }, + { + "Token": { + "item": { + "name": "VersionSpecifier", + "definitions": [{ "scanner": { "Fragment": { "reference": "VersionSpecifierFragment" } } }] + } + } + }, + { + "Token": { + "item": { + "name": "SingleQuotedVersionLiteral", + "definitions": [ + { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "'" } }, + { "Fragment": { "reference": "VersionSpecifierFragment" } }, + { + "ZeroOrMore": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "." } }, + { "Fragment": { "reference": "VersionSpecifierFragment" } } + ] + } + } + } + }, + { "Atom": { "atom": "'" } } + ] + } + } + } + ] + } + } + }, + { + "Token": { + "item": { + "name": "DoubleQuotedVersionLiteral", + "definitions": [ + { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "\"" } }, + { "Fragment": { "reference": "VersionSpecifierFragment" } }, + { + "ZeroOrMore": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "." } }, + { "Fragment": { "reference": "VersionSpecifierFragment" } } + ] + } + } + } + }, + { "Atom": { "atom": "\"" } } + ] + } + } + } + ] + } + } + }, + { + "Fragment": { + "item": { + "name": "VersionSpecifierFragment", + "scanner": { + "OneOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Range": { "inclusive_start": "0", "inclusive_end": "9" } }, + { "Atom": { "atom": "x" } }, + { "Atom": { "atom": "X" } }, + { "Atom": { "atom": "*" } } + ] + } + } + } + } + } + } + }, + { + "Keyword": { + "item": { + "name": "AbicoderKeyword", + "identifier": "Identifier", + "definitions": [{ "reserved": "Never", "value": { "Atom": { "atom": "abicoder" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ExperimentalKeyword", + "identifier": "Identifier", + "definitions": [{ "reserved": "Never", "value": { "Atom": { "atom": "experimental" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "SolidityKeyword", + "identifier": "Identifier", + "definitions": [{ "reserved": "Never", "value": { "Atom": { "atom": "solidity" } } }] + } + } + } + ] + }, + { + "title": "Import Directives", + "items": [ + { + "Struct": { + "item": { + "name": "ImportDirective", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "import_keyword": { "Required": { "reference": "ImportKeyword" } }, + "clause": { "Required": { "reference": "ImportClause" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "ImportClause", + "variants": [ + { "reference": "PathImport" }, + { "reference": "NamedImport" }, + { "reference": "ImportDeconstruction" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "PathImport", + "fields": { + "path": { "Required": { "reference": "StringLiteral" } }, + "alias": { "Optional": { "reference": "ImportAlias" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "NamedImport", + "fields": { + "asterisk": { "Required": { "reference": "Asterisk" } }, + "alias": { "Required": { "reference": "ImportAlias" } }, + "from_keyword": { "Required": { "reference": "FromKeyword" } }, + "path": { "Required": { "reference": "StringLiteral" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ImportDeconstruction", + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "symbols": { "Required": { "reference": "ImportDeconstructionSymbols" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } }, + "from_keyword": { "Required": { "reference": "FromKeyword" } }, + "path": { "Required": { "reference": "StringLiteral" } } + } + } + } + }, + { + "Separated": { + "item": { + "name": "ImportDeconstructionSymbols", + "reference": "ImportDeconstructionSymbol", + "separator": "Comma" + } + } + }, + { + "Struct": { + "item": { + "name": "ImportDeconstructionSymbol", + "fields": { + "name": { "Required": { "reference": "Identifier" } }, + "alias": { "Optional": { "reference": "ImportAlias" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ImportAlias", + "fields": { + "as_keyword": { "Required": { "reference": "AsKeyword" } }, + "identifier": { "Required": { "reference": "Identifier" } } + } + } + } + } + ] + }, + { + "title": "Using Directives", + "items": [ + { + "Struct": { + "item": { + "name": "UsingDirective", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "using_keyword": { "Required": { "reference": "UsingKeyword" } }, + "clause": { "Required": { "reference": "UsingClause" } }, + "for_keyword": { "Required": { "reference": "ForKeyword" } }, + "target": { "Required": { "reference": "UsingTarget" } }, + "global_keyword": { + "Optional": { "reference": "GlobalKeyword", "enabled": { "From": { "from": "0.8.13" } } } + }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "UsingClause", + "variants": [ + { "reference": "IdentifierPath" }, + { "reference": "UsingDeconstruction", "enabled": { "From": { "from": "0.8.13" } } } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "UsingDeconstruction", + "enabled": { "From": { "from": "0.8.13" } }, + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "symbols": { "Required": { "reference": "UsingDeconstructionSymbols" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + } + }, + { + "Separated": { + "item": { + "name": "UsingDeconstructionSymbols", + "reference": "UsingDeconstructionSymbol", + "separator": "Comma", + "enabled": { "From": { "from": "0.8.13" } } + } + } + }, + { + "Struct": { + "item": { + "name": "UsingDeconstructionSymbol", + "enabled": { "From": { "from": "0.8.13" } }, + "fields": { + "name": { "Required": { "reference": "IdentifierPath" } }, + "alias": { "Optional": { "reference": "UsingAlias", "enabled": { "From": { "from": "0.8.19" } } } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "UsingAlias", + "enabled": { "From": { "from": "0.8.19" } }, + "fields": { + "as_keyword": { "Required": { "reference": "AsKeyword" } }, + "operator": { "Required": { "reference": "UsingOperator" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "UsingOperator", + "enabled": { "From": { "from": "0.8.19" } }, + "variants": [ + { "reference": "Ampersand" }, + { "reference": "Asterisk" }, + { "reference": "BangEqual" }, + { "reference": "Bar" }, + { "reference": "Caret" }, + { "reference": "EqualEqual" }, + { "reference": "GreaterThan" }, + { "reference": "GreaterThanEqual" }, + { "reference": "LessThan" }, + { "reference": "LessThanEqual" }, + { "reference": "Minus" }, + { "reference": "Percent" }, + { "reference": "Plus" }, + { "reference": "Slash" }, + { "reference": "Tilde" } + ] + } + } + }, + { + "Enum": { + "item": { + "name": "UsingTarget", + "variants": [{ "reference": "TypeName" }, { "reference": "Asterisk" }] + } + } + } + ] + }, + { + "title": "Trivia", + "items": [ + { + "Trivia": { + "item": { + "name": "Whitespace", + "scanner": { + "OneOrMore": { + "scanner": { + "Choice": { "scanners": [{ "Atom": { "atom": " " } }, { "Atom": { "atom": "\t" } }] } + } + } + } + } + } + }, + { + "Trivia": { + "item": { + "name": "EndOfLine", + "scanner": { + "Choice": { + "scanners": [ + { "Atom": { "atom": "\n" } }, + { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "\r" } }, + { "Optional": { "scanner": { "Atom": { "atom": "\n" } } } } + ] + } + } + ] + } + } + } + } + }, + { + "Trivia": { + "item": { + "name": "SingleLineComment", + "scanner": { + "Sequence": { + "scanners": [ + { + "TrailingContext": { + "scanner": { "Atom": { "atom": "//" } }, + "not_followed_by": { "Atom": { "atom": "/" } } + } + }, + { "ZeroOrMore": { "scanner": { "Not": { "chars": ["\r", "\n"] } } } } + ] + } + } + } + } + }, + { + "Trivia": { + "item": { + "name": "MultiLineComment", + "scanner": { + "Sequence": { + "scanners": [ + { + "TrailingContext": { + "scanner": { "Atom": { "atom": "/*" } }, + "not_followed_by": { + "Sequence": { "scanners": [{ "Atom": { "atom": "*" } }, { "Not": { "chars": ["/"] } }] } + } + } + }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Not": { "chars": ["*"] } }, + { + "TrailingContext": { + "scanner": { "Atom": { "atom": "*" } }, + "not_followed_by": { "Atom": { "atom": "/" } } + } + } + ] + } + } + } + }, + { "Atom": { "atom": "*/" } } + ] + } + } + } + } + }, + { + "Trivia": { + "item": { + "name": "SingleLineNatSpecComment", + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "///" } }, + { "ZeroOrMore": { "scanner": { "Not": { "chars": ["\r", "\n"] } } } } + ] + } + } + } + } + }, + { + "Trivia": { + "item": { + "name": "MultiLineNatSpecComment", + "scanner": { + "Sequence": { + "scanners": [ + { + "TrailingContext": { + "scanner": { "Atom": { "atom": "/**" } }, + "not_followed_by": { "Atom": { "atom": "/" } } + } + }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Not": { "chars": ["*"] } }, + { + "TrailingContext": { + "scanner": { "Atom": { "atom": "*" } }, + "not_followed_by": { "Atom": { "atom": "/" } } + } + } + ] + } + } + } + }, + { "Atom": { "atom": "*/" } } + ] + } + } + } + } + } + ] + }, + { "title": "Nat Spec Format", "items": [] }, + { + "title": "Keywords", + "items": [ + { + "Keyword": { + "item": { + "name": "AbstractKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "From": { "from": "0.6.0" } }, "value": { "Atom": { "atom": "abstract" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "AddressKeyword", + "identifier": "Identifier", + "definitions": [{ "reserved": "Never", "value": { "Atom": { "atom": "address" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "AfterKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "after" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "AliasKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "alias" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "AnonymousKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "anonymous" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ApplyKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "apply" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "AsKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "as" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "AssemblyKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "assembly" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "AutoKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "auto" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "BoolKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "bool" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "BreakKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "break" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ByteKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "Till": { "till": "0.8.0" } }, "value": { "Atom": { "atom": "byte" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "BytesKeyword", + "identifier": "Identifier", + "definitions": [ + { + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "bytes" } }, + { + "Optional": { + "value": { + "Choice": { + "values": [ + { "Atom": { "atom": "1" } }, + { "Atom": { "atom": "2" } }, + { "Atom": { "atom": "3" } }, + { "Atom": { "atom": "4" } }, + { "Atom": { "atom": "5" } }, + { "Atom": { "atom": "6" } }, + { "Atom": { "atom": "7" } }, + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "9" } }, + { "Atom": { "atom": "10" } }, + { "Atom": { "atom": "11" } }, + { "Atom": { "atom": "12" } }, + { "Atom": { "atom": "13" } }, + { "Atom": { "atom": "14" } }, + { "Atom": { "atom": "15" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "17" } }, + { "Atom": { "atom": "18" } }, + { "Atom": { "atom": "19" } }, + { "Atom": { "atom": "20" } }, + { "Atom": { "atom": "21" } }, + { "Atom": { "atom": "22" } }, + { "Atom": { "atom": "23" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "25" } }, + { "Atom": { "atom": "26" } }, + { "Atom": { "atom": "27" } }, + { "Atom": { "atom": "28" } }, + { "Atom": { "atom": "29" } }, + { "Atom": { "atom": "30" } }, + { "Atom": { "atom": "31" } }, + { "Atom": { "atom": "32" } } + ] + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "CallDataKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.5.0" } }, + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "calldata" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "CaseKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "case" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "CatchKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "From": { "from": "0.6.0" } }, "value": { "Atom": { "atom": "catch" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "ConstantKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "constant" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ConstructorKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.4.22" } }, + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "constructor" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "ContinueKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "continue" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ContractKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "contract" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "CopyOfKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "copyof" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "DaysKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "days" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "DefaultKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "default" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "DefineKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "define" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "DeleteKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "delete" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "DoKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "do" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ElseKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "else" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "EmitKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.4.21" } }, + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "emit" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "EnumKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "enum" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ErrorKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.4" } }, + "reserved": "Never", + "value": { "Atom": { "atom": "error" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "EtherKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "ether" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "EventKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "event" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ExternalKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "external" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "FallbackKeyword", + "identifier": "Identifier", + "definitions": [ + { "reserved": { "From": { "from": "0.6.0" } }, "value": { "Atom": { "atom": "fallback" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "FalseKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "false" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "FinalKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "final" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "FinneyKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "Till": { "till": "0.7.0" } }, + "reserved": { "Till": { "till": "0.7.0" } }, + "value": { "Atom": { "atom": "finney" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "FixedKeyword", + "identifier": "Identifier", + "definitions": [ + { "value": { "Atom": { "atom": "fixed" } } }, + { + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "fixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } } + ] + } + }, + { "Atom": { "atom": "x" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } } + ] + } + } + ] + } + } + }, + { + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "fixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "184x8" } }, + { "Atom": { "atom": "184x16" } }, + { "Atom": { "atom": "184x24" } }, + { "Atom": { "atom": "184x32" } }, + { "Atom": { "atom": "184x40" } }, + { "Atom": { "atom": "184x48" } }, + { "Atom": { "atom": "184x56" } }, + { "Atom": { "atom": "184x64" } }, + { "Atom": { "atom": "184x72" } }, + { "Atom": { "atom": "192x8" } }, + { "Atom": { "atom": "192x16" } }, + { "Atom": { "atom": "192x24" } }, + { "Atom": { "atom": "192x32" } }, + { "Atom": { "atom": "192x40" } }, + { "Atom": { "atom": "192x48" } }, + { "Atom": { "atom": "192x56" } }, + { "Atom": { "atom": "192x64" } }, + { "Atom": { "atom": "200x8" } }, + { "Atom": { "atom": "200x16" } }, + { "Atom": { "atom": "200x24" } }, + { "Atom": { "atom": "200x32" } }, + { "Atom": { "atom": "200x40" } }, + { "Atom": { "atom": "200x48" } }, + { "Atom": { "atom": "200x56" } }, + { "Atom": { "atom": "208x8" } }, + { "Atom": { "atom": "208x16" } }, + { "Atom": { "atom": "208x24" } }, + { "Atom": { "atom": "208x32" } }, + { "Atom": { "atom": "208x40" } }, + { "Atom": { "atom": "208x48" } }, + { "Atom": { "atom": "216x8" } }, + { "Atom": { "atom": "216x16" } }, + { "Atom": { "atom": "216x24" } }, + { "Atom": { "atom": "216x32" } }, + { "Atom": { "atom": "216x40" } }, + { "Atom": { "atom": "224x8" } }, + { "Atom": { "atom": "224x16" } }, + { "Atom": { "atom": "224x24" } }, + { "Atom": { "atom": "224x32" } }, + { "Atom": { "atom": "232x8" } }, + { "Atom": { "atom": "232x16" } }, + { "Atom": { "atom": "232x24" } }, + { "Atom": { "atom": "240x8" } }, + { "Atom": { "atom": "240x16" } }, + { "Atom": { "atom": "248x8" } } + ] + } + } + ] + } + } + }, + { + "reserved": { "From": { "from": "0.4.14" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "fixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "184x80" } }, + { "Atom": { "atom": "192x72" } }, + { "Atom": { "atom": "192x80" } }, + { "Atom": { "atom": "200x64" } }, + { "Atom": { "atom": "200x72" } }, + { "Atom": { "atom": "200x80" } }, + { "Atom": { "atom": "208x56" } }, + { "Atom": { "atom": "208x64" } }, + { "Atom": { "atom": "208x72" } }, + { "Atom": { "atom": "208x80" } }, + { "Atom": { "atom": "216x48" } }, + { "Atom": { "atom": "216x56" } }, + { "Atom": { "atom": "216x64" } }, + { "Atom": { "atom": "216x72" } }, + { "Atom": { "atom": "216x80" } }, + { "Atom": { "atom": "224x40" } }, + { "Atom": { "atom": "224x48" } }, + { "Atom": { "atom": "224x56" } }, + { "Atom": { "atom": "224x64" } }, + { "Atom": { "atom": "224x72" } }, + { "Atom": { "atom": "224x80" } }, + { "Atom": { "atom": "232x32" } }, + { "Atom": { "atom": "232x40" } }, + { "Atom": { "atom": "232x48" } }, + { "Atom": { "atom": "232x56" } }, + { "Atom": { "atom": "232x64" } }, + { "Atom": { "atom": "232x72" } }, + { "Atom": { "atom": "232x80" } }, + { "Atom": { "atom": "240x24" } }, + { "Atom": { "atom": "240x32" } }, + { "Atom": { "atom": "240x40" } }, + { "Atom": { "atom": "240x48" } }, + { "Atom": { "atom": "240x56" } }, + { "Atom": { "atom": "240x64" } }, + { "Atom": { "atom": "240x72" } }, + { "Atom": { "atom": "240x80" } }, + { "Atom": { "atom": "248x16" } }, + { "Atom": { "atom": "248x24" } }, + { "Atom": { "atom": "248x32" } }, + { "Atom": { "atom": "248x40" } }, + { "Atom": { "atom": "248x48" } }, + { "Atom": { "atom": "248x56" } }, + { "Atom": { "atom": "248x64" } }, + { "Atom": { "atom": "248x72" } }, + { "Atom": { "atom": "248x80" } }, + { "Atom": { "atom": "256x8" } }, + { "Atom": { "atom": "256x16" } }, + { "Atom": { "atom": "256x24" } }, + { "Atom": { "atom": "256x32" } }, + { "Atom": { "atom": "256x40" } }, + { "Atom": { "atom": "256x48" } }, + { "Atom": { "atom": "256x56" } }, + { "Atom": { "atom": "256x64" } }, + { "Atom": { "atom": "256x72" } }, + { "Atom": { "atom": "256x80" } } + ] + } + } + ] + } + } + }, + { + "reserved": { "From": { "from": "0.4.14" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "fixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } }, + { "Atom": { "atom": "184" } }, + { "Atom": { "atom": "192" } }, + { "Atom": { "atom": "200" } }, + { "Atom": { "atom": "208" } }, + { "Atom": { "atom": "216" } }, + { "Atom": { "atom": "224" } }, + { "Atom": { "atom": "232" } }, + { "Atom": { "atom": "240" } }, + { "Atom": { "atom": "248" } }, + { "Atom": { "atom": "256" } } + ] + } + }, + { "Atom": { "atom": "x" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "0" } }, + { "Atom": { "atom": "1" } }, + { "Atom": { "atom": "2" } }, + { "Atom": { "atom": "3" } }, + { "Atom": { "atom": "4" } }, + { "Atom": { "atom": "5" } }, + { "Atom": { "atom": "6" } }, + { "Atom": { "atom": "7" } }, + { "Atom": { "atom": "9" } }, + { "Atom": { "atom": "10" } }, + { "Atom": { "atom": "11" } }, + { "Atom": { "atom": "12" } }, + { "Atom": { "atom": "13" } }, + { "Atom": { "atom": "14" } }, + { "Atom": { "atom": "15" } }, + { "Atom": { "atom": "17" } }, + { "Atom": { "atom": "18" } }, + { "Atom": { "atom": "19" } }, + { "Atom": { "atom": "20" } }, + { "Atom": { "atom": "21" } }, + { "Atom": { "atom": "22" } }, + { "Atom": { "atom": "23" } }, + { "Atom": { "atom": "25" } }, + { "Atom": { "atom": "26" } }, + { "Atom": { "atom": "27" } }, + { "Atom": { "atom": "28" } }, + { "Atom": { "atom": "29" } }, + { "Atom": { "atom": "30" } }, + { "Atom": { "atom": "31" } }, + { "Atom": { "atom": "33" } }, + { "Atom": { "atom": "34" } }, + { "Atom": { "atom": "35" } }, + { "Atom": { "atom": "36" } }, + { "Atom": { "atom": "37" } }, + { "Atom": { "atom": "38" } }, + { "Atom": { "atom": "39" } }, + { "Atom": { "atom": "41" } }, + { "Atom": { "atom": "42" } }, + { "Atom": { "atom": "43" } }, + { "Atom": { "atom": "44" } }, + { "Atom": { "atom": "45" } }, + { "Atom": { "atom": "46" } }, + { "Atom": { "atom": "47" } }, + { "Atom": { "atom": "49" } }, + { "Atom": { "atom": "50" } }, + { "Atom": { "atom": "51" } }, + { "Atom": { "atom": "52" } }, + { "Atom": { "atom": "53" } }, + { "Atom": { "atom": "54" } }, + { "Atom": { "atom": "55" } }, + { "Atom": { "atom": "57" } }, + { "Atom": { "atom": "58" } }, + { "Atom": { "atom": "59" } }, + { "Atom": { "atom": "60" } }, + { "Atom": { "atom": "61" } }, + { "Atom": { "atom": "62" } }, + { "Atom": { "atom": "63" } }, + { "Atom": { "atom": "65" } }, + { "Atom": { "atom": "66" } }, + { "Atom": { "atom": "67" } }, + { "Atom": { "atom": "68" } }, + { "Atom": { "atom": "69" } }, + { "Atom": { "atom": "70" } }, + { "Atom": { "atom": "71" } }, + { "Atom": { "atom": "73" } }, + { "Atom": { "atom": "74" } }, + { "Atom": { "atom": "75" } }, + { "Atom": { "atom": "76" } }, + { "Atom": { "atom": "77" } }, + { "Atom": { "atom": "78" } }, + { "Atom": { "atom": "79" } } + ] + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "ForKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "for" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "FromKeyword", + "identifier": "Identifier", + "definitions": [{ "reserved": "Never", "value": { "Atom": { "atom": "from" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "FunctionKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "function" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "GlobalKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.13" } }, + "reserved": "Never", + "value": { "Atom": { "atom": "global" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "GweiKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.6.11" } }, + "reserved": { "From": { "from": "0.7.0" } }, + "value": { "Atom": { "atom": "gwei" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "HexKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "hex" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "HoursKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "hours" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "IfKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "if" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ImmutableKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.6.5" } }, + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "immutable" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "ImplementsKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "implements" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "ImportKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "import" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "IndexedKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "indexed" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "InKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "in" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "InlineKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "inline" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "InterfaceKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "interface" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "InternalKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "internal" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "IntKeyword", + "identifier": "Identifier", + "definitions": [ + { + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "int" } }, + { + "Optional": { + "value": { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } }, + { "Atom": { "atom": "184" } }, + { "Atom": { "atom": "192" } }, + { "Atom": { "atom": "200" } }, + { "Atom": { "atom": "208" } }, + { "Atom": { "atom": "216" } }, + { "Atom": { "atom": "224" } }, + { "Atom": { "atom": "232" } }, + { "Atom": { "atom": "240" } }, + { "Atom": { "atom": "248" } }, + { "Atom": { "atom": "256" } } + ] + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "IsKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "is" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "LetKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "let" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "LibraryKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "library" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "MacroKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "macro" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "MappingKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "mapping" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "MatchKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "match" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "MemoryKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "memory" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "MinutesKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "minutes" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ModifierKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "modifier" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "MutableKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "mutable" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "NewKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "new" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "NullKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "null" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "OfKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "of" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "OverrideKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.6.0" } }, + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "override" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "PartialKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "partial" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "PayableKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "payable" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "PragmaKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "pragma" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "PrivateKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "private" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "PromiseKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "promise" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "PublicKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "public" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "PureKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "From": { "from": "0.4.16" } }, "value": { "Atom": { "atom": "pure" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "ReceiveKeyword", + "identifier": "Identifier", + "definitions": [ + { "reserved": { "From": { "from": "0.6.0" } }, "value": { "Atom": { "atom": "receive" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "ReferenceKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "reference" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "RelocatableKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "relocatable" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ReturnKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "return" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ReturnsKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "returns" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "RevertKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.4" } }, + "reserved": "Never", + "value": { "Atom": { "atom": "revert" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "SealedKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "sealed" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "SecondsKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "seconds" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "SizeOfKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "sizeof" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "StaticKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "static" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "StorageKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "storage" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "StringKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "string" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "StructKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "struct" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "SuperKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "super" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "SupportsKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "supports" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "SwitchKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "switch" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "SzaboKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "Till": { "till": "0.7.0" } }, + "reserved": { "Till": { "till": "0.7.0" } }, + "value": { "Atom": { "atom": "szabo" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "ThisKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "this" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "ThrowKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "Till": { "till": "0.5.0" } }, "value": { "Atom": { "atom": "throw" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "TransientKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.27" } }, + "reserved": "Never", + "value": { "Atom": { "atom": "transient" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "TrueKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "true" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "TryKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "From": { "from": "0.6.0" } }, "value": { "Atom": { "atom": "try" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "TypeDefKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "typedef" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "TypeKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "From": { "from": "0.5.3" } }, "value": { "Atom": { "atom": "type" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "TypeOfKeyword", + "identifier": "Identifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "typeof" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "UfixedKeyword", + "identifier": "Identifier", + "definitions": [ + { "value": { "Atom": { "atom": "ufixed" } } }, + { + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "ufixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } } + ] + } + }, + { "Atom": { "atom": "x" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } } + ] + } + } + ] + } + } + }, + { + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "ufixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "184x8" } }, + { "Atom": { "atom": "184x16" } }, + { "Atom": { "atom": "184x24" } }, + { "Atom": { "atom": "184x32" } }, + { "Atom": { "atom": "184x40" } }, + { "Atom": { "atom": "184x48" } }, + { "Atom": { "atom": "184x56" } }, + { "Atom": { "atom": "184x64" } }, + { "Atom": { "atom": "184x72" } }, + { "Atom": { "atom": "192x8" } }, + { "Atom": { "atom": "192x16" } }, + { "Atom": { "atom": "192x24" } }, + { "Atom": { "atom": "192x32" } }, + { "Atom": { "atom": "192x40" } }, + { "Atom": { "atom": "192x48" } }, + { "Atom": { "atom": "192x56" } }, + { "Atom": { "atom": "192x64" } }, + { "Atom": { "atom": "200x8" } }, + { "Atom": { "atom": "200x16" } }, + { "Atom": { "atom": "200x24" } }, + { "Atom": { "atom": "200x32" } }, + { "Atom": { "atom": "200x40" } }, + { "Atom": { "atom": "200x48" } }, + { "Atom": { "atom": "200x56" } }, + { "Atom": { "atom": "208x8" } }, + { "Atom": { "atom": "208x16" } }, + { "Atom": { "atom": "208x24" } }, + { "Atom": { "atom": "208x32" } }, + { "Atom": { "atom": "208x40" } }, + { "Atom": { "atom": "208x48" } }, + { "Atom": { "atom": "216x8" } }, + { "Atom": { "atom": "216x16" } }, + { "Atom": { "atom": "216x24" } }, + { "Atom": { "atom": "216x32" } }, + { "Atom": { "atom": "216x40" } }, + { "Atom": { "atom": "224x8" } }, + { "Atom": { "atom": "224x16" } }, + { "Atom": { "atom": "224x24" } }, + { "Atom": { "atom": "224x32" } }, + { "Atom": { "atom": "232x8" } }, + { "Atom": { "atom": "232x16" } }, + { "Atom": { "atom": "232x24" } }, + { "Atom": { "atom": "240x8" } }, + { "Atom": { "atom": "240x16" } }, + { "Atom": { "atom": "248x8" } } + ] + } + } + ] + } + } + }, + { + "reserved": { "From": { "from": "0.4.14" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "ufixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "184x80" } }, + { "Atom": { "atom": "192x72" } }, + { "Atom": { "atom": "192x80" } }, + { "Atom": { "atom": "200x64" } }, + { "Atom": { "atom": "200x72" } }, + { "Atom": { "atom": "200x80" } }, + { "Atom": { "atom": "208x56" } }, + { "Atom": { "atom": "208x64" } }, + { "Atom": { "atom": "208x72" } }, + { "Atom": { "atom": "208x80" } }, + { "Atom": { "atom": "216x48" } }, + { "Atom": { "atom": "216x56" } }, + { "Atom": { "atom": "216x64" } }, + { "Atom": { "atom": "216x72" } }, + { "Atom": { "atom": "216x80" } }, + { "Atom": { "atom": "224x40" } }, + { "Atom": { "atom": "224x48" } }, + { "Atom": { "atom": "224x56" } }, + { "Atom": { "atom": "224x64" } }, + { "Atom": { "atom": "224x72" } }, + { "Atom": { "atom": "224x80" } }, + { "Atom": { "atom": "232x32" } }, + { "Atom": { "atom": "232x40" } }, + { "Atom": { "atom": "232x48" } }, + { "Atom": { "atom": "232x56" } }, + { "Atom": { "atom": "232x64" } }, + { "Atom": { "atom": "232x72" } }, + { "Atom": { "atom": "232x80" } }, + { "Atom": { "atom": "240x24" } }, + { "Atom": { "atom": "240x32" } }, + { "Atom": { "atom": "240x40" } }, + { "Atom": { "atom": "240x48" } }, + { "Atom": { "atom": "240x56" } }, + { "Atom": { "atom": "240x64" } }, + { "Atom": { "atom": "240x72" } }, + { "Atom": { "atom": "240x80" } }, + { "Atom": { "atom": "248x16" } }, + { "Atom": { "atom": "248x24" } }, + { "Atom": { "atom": "248x32" } }, + { "Atom": { "atom": "248x40" } }, + { "Atom": { "atom": "248x48" } }, + { "Atom": { "atom": "248x56" } }, + { "Atom": { "atom": "248x64" } }, + { "Atom": { "atom": "248x72" } }, + { "Atom": { "atom": "248x80" } }, + { "Atom": { "atom": "256x8" } }, + { "Atom": { "atom": "256x16" } }, + { "Atom": { "atom": "256x24" } }, + { "Atom": { "atom": "256x32" } }, + { "Atom": { "atom": "256x40" } }, + { "Atom": { "atom": "256x48" } }, + { "Atom": { "atom": "256x56" } }, + { "Atom": { "atom": "256x64" } }, + { "Atom": { "atom": "256x72" } }, + { "Atom": { "atom": "256x80" } } + ] + } + } + ] + } + } + }, + { + "reserved": { "From": { "from": "0.4.14" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "ufixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } }, + { "Atom": { "atom": "184" } }, + { "Atom": { "atom": "192" } }, + { "Atom": { "atom": "200" } }, + { "Atom": { "atom": "208" } }, + { "Atom": { "atom": "216" } }, + { "Atom": { "atom": "224" } }, + { "Atom": { "atom": "232" } }, + { "Atom": { "atom": "240" } }, + { "Atom": { "atom": "248" } }, + { "Atom": { "atom": "256" } } + ] + } + }, + { "Atom": { "atom": "x" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "0" } }, + { "Atom": { "atom": "1" } }, + { "Atom": { "atom": "2" } }, + { "Atom": { "atom": "3" } }, + { "Atom": { "atom": "4" } }, + { "Atom": { "atom": "5" } }, + { "Atom": { "atom": "6" } }, + { "Atom": { "atom": "7" } }, + { "Atom": { "atom": "9" } }, + { "Atom": { "atom": "10" } }, + { "Atom": { "atom": "11" } }, + { "Atom": { "atom": "12" } }, + { "Atom": { "atom": "13" } }, + { "Atom": { "atom": "14" } }, + { "Atom": { "atom": "15" } }, + { "Atom": { "atom": "17" } }, + { "Atom": { "atom": "18" } }, + { "Atom": { "atom": "19" } }, + { "Atom": { "atom": "20" } }, + { "Atom": { "atom": "21" } }, + { "Atom": { "atom": "22" } }, + { "Atom": { "atom": "23" } }, + { "Atom": { "atom": "25" } }, + { "Atom": { "atom": "26" } }, + { "Atom": { "atom": "27" } }, + { "Atom": { "atom": "28" } }, + { "Atom": { "atom": "29" } }, + { "Atom": { "atom": "30" } }, + { "Atom": { "atom": "31" } }, + { "Atom": { "atom": "33" } }, + { "Atom": { "atom": "34" } }, + { "Atom": { "atom": "35" } }, + { "Atom": { "atom": "36" } }, + { "Atom": { "atom": "37" } }, + { "Atom": { "atom": "38" } }, + { "Atom": { "atom": "39" } }, + { "Atom": { "atom": "41" } }, + { "Atom": { "atom": "42" } }, + { "Atom": { "atom": "43" } }, + { "Atom": { "atom": "44" } }, + { "Atom": { "atom": "45" } }, + { "Atom": { "atom": "46" } }, + { "Atom": { "atom": "47" } }, + { "Atom": { "atom": "49" } }, + { "Atom": { "atom": "50" } }, + { "Atom": { "atom": "51" } }, + { "Atom": { "atom": "52" } }, + { "Atom": { "atom": "53" } }, + { "Atom": { "atom": "54" } }, + { "Atom": { "atom": "55" } }, + { "Atom": { "atom": "57" } }, + { "Atom": { "atom": "58" } }, + { "Atom": { "atom": "59" } }, + { "Atom": { "atom": "60" } }, + { "Atom": { "atom": "61" } }, + { "Atom": { "atom": "62" } }, + { "Atom": { "atom": "63" } }, + { "Atom": { "atom": "65" } }, + { "Atom": { "atom": "66" } }, + { "Atom": { "atom": "67" } }, + { "Atom": { "atom": "68" } }, + { "Atom": { "atom": "69" } }, + { "Atom": { "atom": "70" } }, + { "Atom": { "atom": "71" } }, + { "Atom": { "atom": "73" } }, + { "Atom": { "atom": "74" } }, + { "Atom": { "atom": "75" } }, + { "Atom": { "atom": "76" } }, + { "Atom": { "atom": "77" } }, + { "Atom": { "atom": "78" } }, + { "Atom": { "atom": "79" } } + ] + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "UintKeyword", + "identifier": "Identifier", + "definitions": [ + { + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "uint" } }, + { + "Optional": { + "value": { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } }, + { "Atom": { "atom": "184" } }, + { "Atom": { "atom": "192" } }, + { "Atom": { "atom": "200" } }, + { "Atom": { "atom": "208" } }, + { "Atom": { "atom": "216" } }, + { "Atom": { "atom": "224" } }, + { "Atom": { "atom": "232" } }, + { "Atom": { "atom": "240" } }, + { "Atom": { "atom": "248" } }, + { "Atom": { "atom": "256" } } + ] + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "UncheckedKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.0" } }, + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "unchecked" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "UsingKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "using" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "VarKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "Till": { "till": "0.5.0" } }, "value": { "Atom": { "atom": "var" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "ViewKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "From": { "from": "0.4.16" } }, "value": { "Atom": { "atom": "view" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "VirtualKeyword", + "identifier": "Identifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.6.0" } }, + "reserved": { "From": { "from": "0.6.0" } }, + "value": { "Atom": { "atom": "virtual" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "WeeksKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "weeks" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "WeiKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "wei" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "WhileKeyword", + "identifier": "Identifier", + "definitions": [{ "value": { "Atom": { "atom": "while" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YearsKeyword", + "identifier": "Identifier", + "definitions": [ + { "enabled": { "Till": { "till": "0.5.0" } }, "value": { "Atom": { "atom": "years" } } } + ] + } + } + } + ] + }, + { + "title": "Punctuation", + "items": [ + { + "Token": { "item": { "name": "OpenParen", "definitions": [{ "scanner": { "Atom": { "atom": "(" } } }] } } + }, + { + "Token": { "item": { "name": "CloseParen", "definitions": [{ "scanner": { "Atom": { "atom": ")" } } }] } } + }, + { + "Token": { + "item": { "name": "OpenBracket", "definitions": [{ "scanner": { "Atom": { "atom": "[" } } }] } + } + }, + { + "Token": { + "item": { "name": "CloseBracket", "definitions": [{ "scanner": { "Atom": { "atom": "]" } } }] } + } + }, + { + "Token": { "item": { "name": "OpenBrace", "definitions": [{ "scanner": { "Atom": { "atom": "{" } } }] } } + }, + { + "Token": { "item": { "name": "CloseBrace", "definitions": [{ "scanner": { "Atom": { "atom": "}" } } }] } } + }, + { "Token": { "item": { "name": "Comma", "definitions": [{ "scanner": { "Atom": { "atom": "," } } }] } } }, + { "Token": { "item": { "name": "Period", "definitions": [{ "scanner": { "Atom": { "atom": "." } } }] } } }, + { + "Token": { + "item": { "name": "QuestionMark", "definitions": [{ "scanner": { "Atom": { "atom": "?" } } }] } + } + }, + { + "Token": { "item": { "name": "Semicolon", "definitions": [{ "scanner": { "Atom": { "atom": ";" } } }] } } + }, + { "Token": { "item": { "name": "Colon", "definitions": [{ "scanner": { "Atom": { "atom": ":" } } }] } } }, + { + "Token": { + "item": { "name": "ColonEqual", "definitions": [{ "scanner": { "Atom": { "atom": ":=" } } }] } + } + }, + { "Token": { "item": { "name": "Equal", "definitions": [{ "scanner": { "Atom": { "atom": "=" } } }] } } }, + { + "Token": { + "item": { + "name": "EqualColon", + "definitions": [ + { "enabled": { "Till": { "till": "0.5.0" } }, "scanner": { "Atom": { "atom": "=:" } } } + ] + } + } + }, + { + "Token": { + "item": { "name": "EqualEqual", "definitions": [{ "scanner": { "Atom": { "atom": "==" } } }] } + } + }, + { + "Token": { + "item": { "name": "EqualGreaterThan", "definitions": [{ "scanner": { "Atom": { "atom": "=>" } } }] } + } + }, + { + "Token": { "item": { "name": "Asterisk", "definitions": [{ "scanner": { "Atom": { "atom": "*" } } }] } } + }, + { + "Token": { + "item": { "name": "AsteriskEqual", "definitions": [{ "scanner": { "Atom": { "atom": "*=" } } }] } + } + }, + { + "Token": { + "item": { "name": "AsteriskAsterisk", "definitions": [{ "scanner": { "Atom": { "atom": "**" } } }] } + } + }, + { "Token": { "item": { "name": "Bar", "definitions": [{ "scanner": { "Atom": { "atom": "|" } } }] } } }, + { + "Token": { "item": { "name": "BarEqual", "definitions": [{ "scanner": { "Atom": { "atom": "|=" } } }] } } + }, + { "Token": { "item": { "name": "BarBar", "definitions": [{ "scanner": { "Atom": { "atom": "||" } } }] } } }, + { + "Token": { "item": { "name": "Ampersand", "definitions": [{ "scanner": { "Atom": { "atom": "&" } } }] } } + }, + { + "Token": { + "item": { "name": "AmpersandEqual", "definitions": [{ "scanner": { "Atom": { "atom": "&=" } } }] } + } + }, + { + "Token": { + "item": { "name": "AmpersandAmpersand", "definitions": [{ "scanner": { "Atom": { "atom": "&&" } } }] } + } + }, + { + "Token": { "item": { "name": "LessThan", "definitions": [{ "scanner": { "Atom": { "atom": "<" } } }] } } + }, + { + "Token": { + "item": { "name": "LessThanEqual", "definitions": [{ "scanner": { "Atom": { "atom": "<=" } } }] } + } + }, + { + "Token": { + "item": { "name": "LessThanLessThan", "definitions": [{ "scanner": { "Atom": { "atom": "<<" } } }] } + } + }, + { + "Token": { + "item": { + "name": "LessThanLessThanEqual", + "definitions": [{ "scanner": { "Atom": { "atom": "<<=" } } }] + } + } + }, + { + "Token": { + "item": { "name": "GreaterThan", "definitions": [{ "scanner": { "Atom": { "atom": ">" } } }] } + } + }, + { + "Token": { + "item": { "name": "GreaterThanEqual", "definitions": [{ "scanner": { "Atom": { "atom": ">=" } } }] } + } + }, + { + "Token": { + "item": { + "name": "GreaterThanGreaterThan", + "definitions": [{ "scanner": { "Atom": { "atom": ">>" } } }] + } + } + }, + { + "Token": { + "item": { + "name": "GreaterThanGreaterThanEqual", + "definitions": [{ "scanner": { "Atom": { "atom": ">>=" } } }] + } + } + }, + { + "Token": { + "item": { + "name": "GreaterThanGreaterThanGreaterThan", + "definitions": [{ "scanner": { "Atom": { "atom": ">>>" } } }] + } + } + }, + { + "Token": { + "item": { + "name": "GreaterThanGreaterThanGreaterThanEqual", + "definitions": [{ "scanner": { "Atom": { "atom": ">>>=" } } }] + } + } + }, + { "Token": { "item": { "name": "Plus", "definitions": [{ "scanner": { "Atom": { "atom": "+" } } }] } } }, + { + "Token": { "item": { "name": "PlusEqual", "definitions": [{ "scanner": { "Atom": { "atom": "+=" } } }] } } + }, + { + "Token": { "item": { "name": "PlusPlus", "definitions": [{ "scanner": { "Atom": { "atom": "++" } } }] } } + }, + { "Token": { "item": { "name": "Minus", "definitions": [{ "scanner": { "Atom": { "atom": "-" } } }] } } }, + { + "Token": { + "item": { "name": "MinusEqual", "definitions": [{ "scanner": { "Atom": { "atom": "-=" } } }] } + } + }, + { + "Token": { + "item": { "name": "MinusMinus", "definitions": [{ "scanner": { "Atom": { "atom": "--" } } }] } + } + }, + { + "Token": { + "item": { "name": "MinusGreaterThan", "definitions": [{ "scanner": { "Atom": { "atom": "->" } } }] } + } + }, + { + "Token": { + "item": { + "name": "Slash", + "definitions": [ + { + "scanner": { + "TrailingContext": { + "scanner": { "Atom": { "atom": "/" } }, + "not_followed_by": { + "Choice": { + "scanners": [ + { "Atom": { "atom": "*" } }, + { "Atom": { "atom": "/" } }, + { "Atom": { "atom": "=" } } + ] + } + } + } + } + } + ] + } + } + }, + { + "Token": { + "item": { "name": "SlashEqual", "definitions": [{ "scanner": { "Atom": { "atom": "/=" } } }] } + } + }, + { "Token": { "item": { "name": "Percent", "definitions": [{ "scanner": { "Atom": { "atom": "%" } } }] } } }, + { + "Token": { + "item": { "name": "PercentEqual", "definitions": [{ "scanner": { "Atom": { "atom": "%=" } } }] } + } + }, + { "Token": { "item": { "name": "Bang", "definitions": [{ "scanner": { "Atom": { "atom": "!" } } }] } } }, + { + "Token": { "item": { "name": "BangEqual", "definitions": [{ "scanner": { "Atom": { "atom": "!=" } } }] } } + }, + { "Token": { "item": { "name": "Caret", "definitions": [{ "scanner": { "Atom": { "atom": "^" } } }] } } }, + { + "Token": { + "item": { "name": "CaretEqual", "definitions": [{ "scanner": { "Atom": { "atom": "^=" } } }] } + } + }, + { "Token": { "item": { "name": "Tilde", "definitions": [{ "scanner": { "Atom": { "atom": "~" } } }] } } } + ] + } + ] + }, + { + "title": "Definitions", + "topics": [ + { + "title": "Contracts", + "items": [ + { + "Struct": { + "item": { + "name": "ContractDefinition", + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "abstract_keyword": { + "Optional": { "reference": "AbstractKeyword", "enabled": { "From": { "from": "0.6.0" } } } + }, + "contract_keyword": { "Required": { "reference": "ContractKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "inheritance": { "Optional": { "reference": "InheritanceSpecifier" } }, + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "members": { "Required": { "reference": "ContractMembers" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "InheritanceSpecifier", + "fields": { + "is_keyword": { "Required": { "reference": "IsKeyword" } }, + "types": { "Required": { "reference": "InheritanceTypes" } } + } + } + } + }, + { + "Separated": { + "item": { "name": "InheritanceTypes", "reference": "InheritanceType", "separator": "Comma" } + } + }, + { + "Struct": { + "item": { + "name": "InheritanceType", + "fields": { + "type_name": { "Required": { "reference": "IdentifierPath" } }, + "arguments": { "Optional": { "reference": "ArgumentsDeclaration" } } + } + } + } + }, + { + "Repeated": { "item": { "name": "ContractMembers", "reference": "ContractMember", "allow_empty": true } } + }, + { + "Enum": { + "item": { + "name": "ContractMember", + "variants": [ + { "reference": "UsingDirective" }, + { "reference": "FunctionDefinition" }, + { "reference": "ConstructorDefinition", "enabled": { "From": { "from": "0.4.22" } } }, + { "reference": "ReceiveFunctionDefinition", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "FallbackFunctionDefinition", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "UnnamedFunctionDefinition", "enabled": { "Till": { "till": "0.6.0" } } }, + { "reference": "ModifierDefinition" }, + { "reference": "StructDefinition" }, + { "reference": "EnumDefinition" }, + { "reference": "EventDefinition" }, + { "reference": "ErrorDefinition", "enabled": { "From": { "from": "0.8.4" } } }, + { "reference": "UserDefinedValueTypeDefinition", "enabled": { "From": { "from": "0.8.8" } } }, + { "reference": "StateVariableDefinition" } + ] + } + } + } + ] + }, + { + "title": "Interfaces", + "items": [ + { + "Struct": { + "item": { + "name": "InterfaceDefinition", + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "interface_keyword": { "Required": { "reference": "InterfaceKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "inheritance": { "Optional": { "reference": "InheritanceSpecifier" } }, + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "members": { "Required": { "reference": "InterfaceMembers" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + } + }, + { + "Repeated": { "item": { "name": "InterfaceMembers", "reference": "ContractMember", "allow_empty": true } } + } + ] + }, + { + "title": "Libraries", + "items": [ + { + "Struct": { + "item": { + "name": "LibraryDefinition", + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "library_keyword": { "Required": { "reference": "LibraryKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "members": { "Required": { "reference": "LibraryMembers" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + } + }, + { "Repeated": { "item": { "name": "LibraryMembers", "reference": "ContractMember", "allow_empty": true } } } + ] + }, + { + "title": "Structs", + "items": [ + { + "Struct": { + "item": { + "name": "StructDefinition", + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "struct_keyword": { "Required": { "reference": "StructKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "members": { "Required": { "reference": "StructMembers" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + } + }, + { "Repeated": { "item": { "name": "StructMembers", "reference": "StructMember", "allow_empty": true } } }, + { + "Struct": { + "item": { + "name": "StructMember", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "type_name": { "Required": { "reference": "TypeName" } }, + "name": { "Required": { "reference": "Identifier" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + } + ] + }, + { + "title": "Enums", + "items": [ + { + "Struct": { + "item": { + "name": "EnumDefinition", + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "enum_keyword": { "Required": { "reference": "EnumKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "members": { "Required": { "reference": "EnumMembers" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + } + }, + { + "Separated": { + "item": { "name": "EnumMembers", "reference": "Identifier", "separator": "Comma", "allow_empty": true } + } + } + ] + }, + { + "title": "Constants", + "items": [ + { + "Struct": { + "item": { + "name": "ConstantDefinition", + "enabled": { "From": { "from": "0.7.4" } }, + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "type_name": { "Required": { "reference": "TypeName" } }, + "constant_keyword": { "Required": { "reference": "ConstantKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "equal": { "Required": { "reference": "Equal" } }, + "value": { "Required": { "reference": "Expression" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + } + ] + }, + { + "title": "State Variables", + "items": [ + { + "Struct": { + "item": { + "name": "StateVariableDefinition", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "type_name": { "Required": { "reference": "TypeName" } }, + "attributes": { "Required": { "reference": "StateVariableAttributes" } }, + "name": { "Required": { "reference": "Identifier" } }, + "value": { "Optional": { "reference": "StateVariableDefinitionValue" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "StateVariableDefinitionValue", + "fields": { + "equal": { "Required": { "reference": "Equal" } }, + "value": { "Required": { "reference": "Expression" } } + } + } + } + }, + { + "Repeated": { + "item": { + "name": "StateVariableAttributes", + "reference": "StateVariableAttribute", + "allow_empty": true + } + } + }, + { + "Enum": { + "item": { + "name": "StateVariableAttribute", + "variants": [ + { "reference": "OverrideSpecifier", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "ConstantKeyword" }, + { "reference": "InternalKeyword" }, + { "reference": "PrivateKeyword" }, + { "reference": "PublicKeyword" }, + { "reference": "ImmutableKeyword", "enabled": { "From": { "from": "0.6.5" } } }, + { "reference": "TransientKeyword", "enabled": { "From": { "from": "0.8.27" } } } + ] + } + } + } + ] + }, + { + "title": "Functions", + "items": [ + { + "Struct": { + "item": { + "name": "FunctionDefinition", + "fields": { + "function_keyword": { "Required": { "reference": "FunctionKeyword" } }, + "name": { "Required": { "reference": "FunctionName" } }, + "parameters": { "Required": { "reference": "ParametersDeclaration" } }, + "attributes": { "Required": { "reference": "FunctionAttributes" } }, + "returns": { "Optional": { "reference": "ReturnsDeclaration" } }, + "body": { "Required": { "reference": "FunctionBody" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "FunctionName", + "variants": [ + { "reference": "Identifier" }, + { "reference": "FallbackKeyword" }, + { "reference": "ReceiveKeyword" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "ParametersDeclaration", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "parameters": { "Required": { "reference": "Parameters" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { + "Separated": { + "item": { "name": "Parameters", "reference": "Parameter", "separator": "Comma", "allow_empty": true } + } + }, + { + "Struct": { + "item": { + "name": "Parameter", + "fields": { + "type_name": { "Required": { "reference": "TypeName" } }, + "storage_location": { "Optional": { "reference": "StorageLocation" } }, + "name": { "Optional": { "reference": "Identifier" } } + } + } + } + }, + { + "Repeated": { + "item": { "name": "FunctionAttributes", "reference": "FunctionAttribute", "allow_empty": true } + } + }, + { + "Enum": { + "item": { + "name": "FunctionAttribute", + "variants": [ + { "reference": "ModifierInvocation" }, + { "reference": "OverrideSpecifier", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "ConstantKeyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "ExternalKeyword" }, + { "reference": "InternalKeyword" }, + { "reference": "PayableKeyword" }, + { "reference": "PrivateKeyword" }, + { "reference": "PublicKeyword" }, + { "reference": "PureKeyword", "enabled": { "From": { "from": "0.4.16" } } }, + { "reference": "ViewKeyword", "enabled": { "From": { "from": "0.4.16" } } }, + { "reference": "VirtualKeyword", "enabled": { "From": { "from": "0.6.0" } } } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "OverrideSpecifier", + "enabled": { "From": { "from": "0.6.0" } }, + "fields": { + "override_keyword": { "Required": { "reference": "OverrideKeyword" } }, + "overridden": { "Optional": { "reference": "OverridePathsDeclaration" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "OverridePathsDeclaration", + "enabled": { "From": { "from": "0.6.0" } }, + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "paths": { "Required": { "reference": "OverridePaths" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { + "Separated": { + "item": { + "name": "OverridePaths", + "reference": "IdentifierPath", + "separator": "Comma", + "enabled": { "From": { "from": "0.6.0" } } + } + } + }, + { + "Struct": { + "item": { + "name": "ReturnsDeclaration", + "fields": { + "returns_keyword": { "Required": { "reference": "ReturnsKeyword" } }, + "variables": { "Required": { "reference": "ParametersDeclaration" } } + } + } + } + }, + { + "Enum": { + "item": { "name": "FunctionBody", "variants": [{ "reference": "Block" }, { "reference": "Semicolon" }] } + } + }, + { + "Struct": { + "item": { + "name": "ConstructorDefinition", + "enabled": { "From": { "from": "0.4.22" } }, + "fields": { + "constructor_keyword": { "Required": { "reference": "ConstructorKeyword" } }, + "parameters": { "Required": { "reference": "ParametersDeclaration" } }, + "attributes": { "Required": { "reference": "ConstructorAttributes" } }, + "body": { "Required": { "reference": "Block" } } + } + } + } + }, + { + "Repeated": { + "item": { + "name": "ConstructorAttributes", + "reference": "ConstructorAttribute", + "enabled": { "From": { "from": "0.4.22" } }, + "allow_empty": true + } + } + }, + { + "Enum": { + "item": { + "name": "ConstructorAttribute", + "enabled": { "From": { "from": "0.4.22" } }, + "variants": [ + { "reference": "ModifierInvocation" }, + { "reference": "InternalKeyword" }, + { "reference": "OverrideKeyword", "enabled": { "Range": { "from": "0.6.0", "till": "0.6.7" } } }, + { "reference": "PayableKeyword" }, + { "reference": "PublicKeyword" }, + { "reference": "VirtualKeyword", "enabled": { "Range": { "from": "0.6.0", "till": "0.6.7" } } } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "UnnamedFunctionDefinition", + "enabled": { "Till": { "till": "0.6.0" } }, + "fields": { + "function_keyword": { "Required": { "reference": "FunctionKeyword" } }, + "parameters": { "Required": { "reference": "ParametersDeclaration" } }, + "attributes": { "Required": { "reference": "UnnamedFunctionAttributes" } }, + "body": { "Required": { "reference": "FunctionBody" } } + } + } + } + }, + { + "Repeated": { + "item": { + "name": "UnnamedFunctionAttributes", + "reference": "UnnamedFunctionAttribute", + "enabled": { "Till": { "till": "0.6.0" } }, + "allow_empty": true + } + } + }, + { + "Enum": { + "item": { + "name": "UnnamedFunctionAttribute", + "enabled": { "Till": { "till": "0.6.0" } }, + "variants": [ + { "reference": "ModifierInvocation" }, + { "reference": "ConstantKeyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "ExternalKeyword" }, + { "reference": "InternalKeyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "PayableKeyword" }, + { "reference": "PrivateKeyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "PublicKeyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "PureKeyword", "enabled": { "Range": { "from": "0.4.16", "till": "0.6.0" } } }, + { "reference": "ViewKeyword", "enabled": { "Range": { "from": "0.4.16", "till": "0.6.0" } } } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "FallbackFunctionDefinition", + "enabled": { "From": { "from": "0.6.0" } }, + "fields": { + "fallback_keyword": { "Required": { "reference": "FallbackKeyword" } }, + "parameters": { "Required": { "reference": "ParametersDeclaration" } }, + "attributes": { "Required": { "reference": "FallbackFunctionAttributes" } }, + "returns": { "Optional": { "reference": "ReturnsDeclaration" } }, + "body": { "Required": { "reference": "FunctionBody" } } + } + } + } + }, + { + "Repeated": { + "item": { + "name": "FallbackFunctionAttributes", + "reference": "FallbackFunctionAttribute", + "enabled": { "From": { "from": "0.6.0" } }, + "allow_empty": true + } + } + }, + { + "Enum": { + "item": { + "name": "FallbackFunctionAttribute", + "enabled": { "From": { "from": "0.6.0" } }, + "variants": [ + { "reference": "ModifierInvocation" }, + { "reference": "OverrideSpecifier" }, + { "reference": "ExternalKeyword" }, + { "reference": "PayableKeyword" }, + { "reference": "PureKeyword" }, + { "reference": "ViewKeyword" }, + { "reference": "VirtualKeyword" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "ReceiveFunctionDefinition", + "enabled": { "From": { "from": "0.6.0" } }, + "fields": { + "receive_keyword": { "Required": { "reference": "ReceiveKeyword" } }, + "parameters": { "Required": { "reference": "ParametersDeclaration" } }, + "attributes": { "Required": { "reference": "ReceiveFunctionAttributes" } }, + "body": { "Required": { "reference": "FunctionBody" } } + } + } + } + }, + { + "Repeated": { + "item": { + "name": "ReceiveFunctionAttributes", + "reference": "ReceiveFunctionAttribute", + "enabled": { "From": { "from": "0.6.0" } }, + "allow_empty": true + } + } + }, + { + "Enum": { + "item": { + "name": "ReceiveFunctionAttribute", + "enabled": { "From": { "from": "0.6.0" } }, + "variants": [ + { "reference": "ModifierInvocation" }, + { "reference": "OverrideSpecifier" }, + { "reference": "ExternalKeyword" }, + { "reference": "PayableKeyword" }, + { "reference": "VirtualKeyword" } + ] + } + } + } + ] + }, + { + "title": "Modifiers", + "items": [ + { + "Struct": { + "item": { + "name": "ModifierDefinition", + "fields": { + "modifier_keyword": { "Required": { "reference": "ModifierKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "parameters": { "Optional": { "reference": "ParametersDeclaration" } }, + "attributes": { "Required": { "reference": "ModifierAttributes" } }, + "body": { "Required": { "reference": "FunctionBody" } } + } + } + } + }, + { + "Repeated": { + "item": { "name": "ModifierAttributes", "reference": "ModifierAttribute", "allow_empty": true } + } + }, + { + "Enum": { + "item": { + "name": "ModifierAttribute", + "variants": [ + { "reference": "OverrideSpecifier", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "VirtualKeyword", "enabled": { "From": { "from": "0.6.0" } } } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "ModifierInvocation", + "fields": { + "name": { "Required": { "reference": "IdentifierPath" } }, + "arguments": { "Optional": { "reference": "ArgumentsDeclaration" } } + } + } + } + } + ] + }, + { + "title": "Events", + "items": [ + { + "Struct": { + "item": { + "name": "EventDefinition", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "event_keyword": { "Required": { "reference": "EventKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "parameters": { "Required": { "reference": "EventParametersDeclaration" } }, + "anonymous_keyword": { "Optional": { "reference": "AnonymousKeyword" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "EventParametersDeclaration", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "parameters": { "Required": { "reference": "EventParameters" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { + "Separated": { + "item": { + "name": "EventParameters", + "reference": "EventParameter", + "separator": "Comma", + "allow_empty": true + } + } + }, + { + "Struct": { + "item": { + "name": "EventParameter", + "fields": { + "type_name": { "Required": { "reference": "TypeName" } }, + "indexed_keyword": { "Optional": { "reference": "IndexedKeyword" } }, + "name": { "Optional": { "reference": "Identifier" } } + } + } + } + } + ] + }, + { + "title": "User Defined Value Types", + "items": [ + { + "Struct": { + "item": { + "name": "UserDefinedValueTypeDefinition", + "enabled": { "From": { "from": "0.8.8" } }, + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "type_keyword": { "Required": { "reference": "TypeKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "is_keyword": { "Required": { "reference": "IsKeyword" } }, + "value_type": { "Required": { "reference": "ElementaryType" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + } + ] + }, + { + "title": "Errors", + "items": [ + { + "Struct": { + "item": { + "name": "ErrorDefinition", + "enabled": { "From": { "from": "0.8.4" } }, + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "error_keyword": { "Required": { "reference": "ErrorKeyword" } }, + "name": { "Required": { "reference": "Identifier" } }, + "members": { "Required": { "reference": "ErrorParametersDeclaration" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ErrorParametersDeclaration", + "enabled": { "From": { "from": "0.8.4" } }, + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "parameters": { "Required": { "reference": "ErrorParameters" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { + "Separated": { + "item": { + "name": "ErrorParameters", + "reference": "ErrorParameter", + "separator": "Comma", + "enabled": { "From": { "from": "0.8.4" } }, + "allow_empty": true + } + } + }, + { + "Struct": { + "item": { + "name": "ErrorParameter", + "enabled": { "From": { "from": "0.8.4" } }, + "fields": { + "type_name": { "Required": { "reference": "TypeName" } }, + "name": { "Optional": { "reference": "Identifier" } } + } + } + } + } + ] + } + ] + }, + { + "title": "Types", + "topics": [ + { + "title": "Advanced Types", + "items": [ + { + "Precedence": { + "item": { + "name": "TypeName", + "precedence_expressions": [ + { + "name": "ArrayTypeName", + "operators": [ + { + "model": "Postfix", + "error_recovery": { "delimiters": { "open": "open_bracket", "close": "close_bracket" } }, + "fields": { + "open_bracket": { "Required": { "reference": "OpenBracket" } }, + "index": { "Optional": { "reference": "Expression" } }, + "close_bracket": { "Required": { "reference": "CloseBracket" } } + } + } + ] + } + ], + "primary_expressions": [ + { "reference": "FunctionType" }, + { "reference": "MappingType" }, + { "reference": "ElementaryType" }, + { "reference": "IdentifierPath" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "FunctionType", + "fields": { + "function_keyword": { "Required": { "reference": "FunctionKeyword" } }, + "parameters": { "Required": { "reference": "ParametersDeclaration" } }, + "attributes": { "Required": { "reference": "FunctionTypeAttributes" } }, + "returns": { "Optional": { "reference": "ReturnsDeclaration" } } + } + } + } + }, + { + "Repeated": { + "item": { "name": "FunctionTypeAttributes", "reference": "FunctionTypeAttribute", "allow_empty": true } + } + }, + { + "Enum": { + "item": { + "name": "FunctionTypeAttribute", + "variants": [ + { "reference": "InternalKeyword" }, + { "reference": "ExternalKeyword" }, + { "reference": "PrivateKeyword" }, + { "reference": "PublicKeyword" }, + { "reference": "ConstantKeyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "PureKeyword", "enabled": { "From": { "from": "0.4.16" } } }, + { "reference": "ViewKeyword", "enabled": { "From": { "from": "0.4.16" } } }, + { "reference": "PayableKeyword" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "MappingType", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "mapping_keyword": { "Required": { "reference": "MappingKeyword" } }, + "open_paren": { "Required": { "reference": "OpenParen" } }, + "key_type": { "Required": { "reference": "MappingKey" } }, + "equal_greater_than": { "Required": { "reference": "EqualGreaterThan" } }, + "value_type": { "Required": { "reference": "MappingValue" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "MappingKey", + "fields": { + "key_type": { "Required": { "reference": "MappingKeyType" } }, + "name": { "Optional": { "reference": "Identifier", "enabled": { "From": { "from": "0.8.18" } } } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "MappingKeyType", + "variants": [{ "reference": "ElementaryType" }, { "reference": "IdentifierPath" }] + } + } + }, + { + "Struct": { + "item": { + "name": "MappingValue", + "fields": { + "type_name": { "Required": { "reference": "TypeName" } }, + "name": { "Optional": { "reference": "Identifier", "enabled": { "From": { "from": "0.8.18" } } } } + } + } + } + } + ] + }, + { + "title": "Elementary Types", + "items": [ + { + "Enum": { + "item": { + "name": "ElementaryType", + "variants": [ + { "reference": "BoolKeyword" }, + { "reference": "ByteKeyword", "enabled": { "Till": { "till": "0.8.0" } } }, + { "reference": "StringKeyword" }, + { "reference": "AddressType" }, + { "reference": "BytesKeyword" }, + { "reference": "IntKeyword" }, + { "reference": "UintKeyword" }, + { "reference": "FixedKeyword" }, + { "reference": "UfixedKeyword" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "AddressType", + "fields": { + "address_keyword": { "Required": { "reference": "AddressKeyword" } }, + "payable_keyword": { "Optional": { "reference": "PayableKeyword" } } + } + } + } + } + ] + } + ] + }, + { + "title": "Statements", + "topics": [ + { + "title": "Blocks", + "items": [ + { + "Struct": { + "item": { + "name": "Block", + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "statements": { "Required": { "reference": "Statements" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + } + }, + { "Repeated": { "item": { "name": "Statements", "reference": "Statement", "allow_empty": true } } }, + { + "Enum": { + "item": { + "name": "Statement", + "variants": [ + { "reference": "IfStatement" }, + { "reference": "ForStatement" }, + { "reference": "WhileStatement" }, + { "reference": "DoWhileStatement" }, + { "reference": "ContinueStatement" }, + { "reference": "BreakStatement" }, + { "reference": "ReturnStatement" }, + { "reference": "ThrowStatement", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "EmitStatement", "enabled": { "From": { "from": "0.4.21" } } }, + { "reference": "TryStatement", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "RevertStatement", "enabled": { "From": { "from": "0.8.4" } } }, + { "reference": "AssemblyStatement" }, + { "reference": "Block" }, + { "reference": "UncheckedBlock", "enabled": { "From": { "from": "0.8.0" } } }, + { "reference": "TupleDeconstructionStatement" }, + { "reference": "VariableDeclarationStatement" }, + { "reference": "ExpressionStatement" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "UncheckedBlock", + "enabled": { "From": { "from": "0.8.0" } }, + "fields": { + "unchecked_keyword": { "Required": { "reference": "UncheckedKeyword" } }, + "block": { "Required": { "reference": "Block" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ExpressionStatement", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "expression": { "Required": { "reference": "Expression" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "AssemblyStatement", + "fields": { + "assembly_keyword": { "Required": { "reference": "AssemblyKeyword" } }, + "label": { "Optional": { "reference": "StringLiteral" } }, + "flags": { "Optional": { "reference": "AssemblyFlagsDeclaration" } }, + "body": { "Required": { "reference": "YulBlock" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "AssemblyFlagsDeclaration", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "flags": { "Required": { "reference": "AssemblyFlags" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { "Separated": { "item": { "name": "AssemblyFlags", "reference": "StringLiteral", "separator": "Comma" } } } + ] + }, + { + "title": "Declaration Statements", + "items": [ + { + "Struct": { + "item": { + "name": "TupleDeconstructionStatement", + "error_recovery": { + "terminator": "semicolon", + "delimiters": { "open": "open_paren", "close": "close_paren" } + }, + "fields": { + "var_keyword": { + "Optional": { "reference": "VarKeyword", "enabled": { "Till": { "till": "0.5.0" } } } + }, + "open_paren": { "Required": { "reference": "OpenParen" } }, + "elements": { "Required": { "reference": "TupleDeconstructionElements" } }, + "close_paren": { "Required": { "reference": "CloseParen" } }, + "equal": { "Required": { "reference": "Equal" } }, + "expression": { "Required": { "reference": "Expression" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Separated": { + "item": { + "name": "TupleDeconstructionElements", + "reference": "TupleDeconstructionElement", + "separator": "Comma" + } + } + }, + { + "Struct": { + "item": { + "name": "TupleDeconstructionElement", + "fields": { "member": { "Optional": { "reference": "TupleMember" } } } + } + } + }, + { + "Enum": { + "item": { + "name": "TupleMember", + "variants": [{ "reference": "TypedTupleMember" }, { "reference": "UntypedTupleMember" }] + } + } + }, + { + "Struct": { + "item": { + "name": "TypedTupleMember", + "fields": { + "type_name": { "Required": { "reference": "TypeName" } }, + "storage_location": { "Optional": { "reference": "StorageLocation" } }, + "name": { "Required": { "reference": "Identifier" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "UntypedTupleMember", + "fields": { + "storage_location": { "Optional": { "reference": "StorageLocation" } }, + "name": { "Required": { "reference": "Identifier" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "VariableDeclarationStatement", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "variable_type": { "Required": { "reference": "VariableDeclarationType" } }, + "storage_location": { "Optional": { "reference": "StorageLocation" } }, + "name": { "Required": { "reference": "Identifier" } }, + "value": { "Optional": { "reference": "VariableDeclarationValue" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "VariableDeclarationType", + "variants": [ + { "reference": "TypeName" }, + { "reference": "VarKeyword", "enabled": { "Till": { "till": "0.5.0" } } } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "VariableDeclarationValue", + "fields": { + "equal": { "Required": { "reference": "Equal" } }, + "expression": { "Required": { "reference": "Expression" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "StorageLocation", + "variants": [ + { "reference": "MemoryKeyword" }, + { "reference": "StorageKeyword" }, + { "reference": "CallDataKeyword", "enabled": { "From": { "from": "0.5.0" } } } + ] + } + } + } + ] + }, + { + "title": "Control Statements", + "items": [ + { + "Struct": { + "item": { + "name": "IfStatement", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "if_keyword": { "Required": { "reference": "IfKeyword" } }, + "open_paren": { "Required": { "reference": "OpenParen" } }, + "condition": { "Required": { "reference": "Expression" } }, + "close_paren": { "Required": { "reference": "CloseParen" } }, + "body": { "Required": { "reference": "Statement" } }, + "else_branch": { "Optional": { "reference": "ElseBranch" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ElseBranch", + "fields": { + "else_keyword": { "Required": { "reference": "ElseKeyword" } }, + "body": { "Required": { "reference": "Statement" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ForStatement", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "for_keyword": { "Required": { "reference": "ForKeyword" } }, + "open_paren": { "Required": { "reference": "OpenParen" } }, + "initialization": { "Required": { "reference": "ForStatementInitialization" } }, + "condition": { "Required": { "reference": "ForStatementCondition" } }, + "iterator": { "Optional": { "reference": "Expression" } }, + "close_paren": { "Required": { "reference": "CloseParen" } }, + "body": { "Required": { "reference": "Statement" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "ForStatementInitialization", + "variants": [ + { "reference": "TupleDeconstructionStatement" }, + { "reference": "VariableDeclarationStatement" }, + { "reference": "ExpressionStatement" }, + { "reference": "Semicolon" } + ] + } + } + }, + { + "Enum": { + "item": { + "name": "ForStatementCondition", + "variants": [{ "reference": "ExpressionStatement" }, { "reference": "Semicolon" }] + } + } + }, + { + "Struct": { + "item": { + "name": "WhileStatement", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "while_keyword": { "Required": { "reference": "WhileKeyword" } }, + "open_paren": { "Required": { "reference": "OpenParen" } }, + "condition": { "Required": { "reference": "Expression" } }, + "close_paren": { "Required": { "reference": "CloseParen" } }, + "body": { "Required": { "reference": "Statement" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "DoWhileStatement", + "error_recovery": { + "terminator": "semicolon", + "delimiters": { "open": "open_paren", "close": "close_paren" } + }, + "fields": { + "do_keyword": { "Required": { "reference": "DoKeyword" } }, + "body": { "Required": { "reference": "Statement" } }, + "while_keyword": { "Required": { "reference": "WhileKeyword" } }, + "open_paren": { "Required": { "reference": "OpenParen" } }, + "condition": { "Required": { "reference": "Expression" } }, + "close_paren": { "Required": { "reference": "CloseParen" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ContinueStatement", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "continue_keyword": { "Required": { "reference": "ContinueKeyword" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "BreakStatement", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "break_keyword": { "Required": { "reference": "BreakKeyword" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ReturnStatement", + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "return_keyword": { "Required": { "reference": "ReturnKeyword" } }, + "expression": { "Optional": { "reference": "Expression" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "EmitStatement", + "enabled": { "From": { "from": "0.4.21" } }, + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "emit_keyword": { "Required": { "reference": "EmitKeyword" } }, + "event": { "Required": { "reference": "IdentifierPath" } }, + "arguments": { "Required": { "reference": "ArgumentsDeclaration" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + } + ] + }, + { + "title": "Error Handling", + "items": [ + { + "Struct": { + "item": { + "name": "TryStatement", + "enabled": { "From": { "from": "0.6.0" } }, + "fields": { + "try_keyword": { "Required": { "reference": "TryKeyword" } }, + "expression": { "Required": { "reference": "Expression" } }, + "returns": { "Optional": { "reference": "ReturnsDeclaration" } }, + "body": { "Required": { "reference": "Block" } }, + "catch_clauses": { "Required": { "reference": "CatchClauses" } } + } + } + } + }, + { + "Repeated": { + "item": { + "name": "CatchClauses", + "reference": "CatchClause", + "enabled": { "From": { "from": "0.6.0" } } + } + } + }, + { + "Struct": { + "item": { + "name": "CatchClause", + "enabled": { "From": { "from": "0.6.0" } }, + "fields": { + "catch_keyword": { "Required": { "reference": "CatchKeyword" } }, + "error": { "Optional": { "reference": "CatchClauseError" } }, + "body": { "Required": { "reference": "Block" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "CatchClauseError", + "enabled": { "From": { "from": "0.6.0" } }, + "fields": { + "name": { "Optional": { "reference": "Identifier" } }, + "parameters": { "Required": { "reference": "ParametersDeclaration" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "RevertStatement", + "enabled": { "From": { "from": "0.8.4" } }, + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "revert_keyword": { "Required": { "reference": "RevertKeyword" } }, + "error": { "Optional": { "reference": "IdentifierPath" } }, + "arguments": { "Required": { "reference": "ArgumentsDeclaration" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "ThrowStatement", + "enabled": { "Till": { "till": "0.5.0" } }, + "error_recovery": { "terminator": "semicolon" }, + "fields": { + "throw_keyword": { "Required": { "reference": "ThrowKeyword" } }, + "semicolon": { "Required": { "reference": "Semicolon" } } + } + } + } + } + ] + } + ] + }, + { + "title": "Expressions", + "topics": [ + { + "title": "Base Expressions", + "items": [ + { + "Precedence": { + "item": { + "name": "Expression", + "precedence_expressions": [ + { + "name": "AssignmentExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "Equal" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "BarEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "PlusEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "MinusEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "CaretEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "SlashEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "PercentEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "AsteriskEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "AmpersandEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "LessThanLessThanEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "GreaterThanGreaterThanEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { + "operator": { "Required": { "reference": "GreaterThanGreaterThanGreaterThanEqual" } } + } + } + ] + }, + { + "name": "ConditionalExpression", + "operators": [ + { + "model": "Postfix", + "fields": { + "question_mark": { "Required": { "reference": "QuestionMark" } }, + "true_expression": { "Required": { "reference": "Expression" } }, + "colon": { "Required": { "reference": "Colon" } }, + "false_expression": { "Required": { "reference": "Expression" } } + } + } + ] + }, + { + "name": "OrExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "BarBar" } } } + } + ] + }, + { + "name": "AndExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "AmpersandAmpersand" } } } + } + ] + }, + { + "name": "EqualityExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "EqualEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "BangEqual" } } } + } + ] + }, + { + "name": "ComparisonExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "LessThan" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "GreaterThan" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "LessThanEqual" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "GreaterThanEqual" } } } + } + ] + }, + { + "name": "BitwiseOrExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "Bar" } } } + } + ] + }, + { + "name": "BitwiseXorExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "Caret" } } } + } + ] + }, + { + "name": "BitwiseAndExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "Ampersand" } } } + } + ] + }, + { + "name": "ShiftExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "LessThanLessThan" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "GreaterThanGreaterThan" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "GreaterThanGreaterThanGreaterThan" } } } + } + ] + }, + { + "name": "AdditiveExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "Plus" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "Minus" } } } + } + ] + }, + { + "name": "MultiplicativeExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "Asterisk" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "Slash" } } } + }, + { + "model": "BinaryLeftAssociative", + "fields": { "operator": { "Required": { "reference": "Percent" } } } + } + ] + }, + { + "name": "ExponentiationExpression", + "operators": [ + { + "model": "BinaryLeftAssociative", + "enabled": { "Till": { "till": "0.8.0" } }, + "fields": { "operator": { "Required": { "reference": "AsteriskAsterisk" } } } + }, + { + "model": "BinaryRightAssociative", + "enabled": { "From": { "from": "0.8.0" } }, + "fields": { "operator": { "Required": { "reference": "AsteriskAsterisk" } } } + } + ] + }, + { + "name": "PostfixExpression", + "operators": [ + { "model": "Postfix", "fields": { "operator": { "Required": { "reference": "PlusPlus" } } } }, + { "model": "Postfix", "fields": { "operator": { "Required": { "reference": "MinusMinus" } } } } + ] + }, + { + "name": "PrefixExpression", + "operators": [ + { "model": "Prefix", "fields": { "operator": { "Required": { "reference": "PlusPlus" } } } }, + { "model": "Prefix", "fields": { "operator": { "Required": { "reference": "MinusMinus" } } } }, + { "model": "Prefix", "fields": { "operator": { "Required": { "reference": "Tilde" } } } }, + { "model": "Prefix", "fields": { "operator": { "Required": { "reference": "Bang" } } } }, + { "model": "Prefix", "fields": { "operator": { "Required": { "reference": "Minus" } } } }, + { + "model": "Prefix", + "enabled": { "Till": { "till": "0.5.0" } }, + "fields": { "operator": { "Required": { "reference": "Plus" } } } + }, + { + "model": "Prefix", + "fields": { "operator": { "Required": { "reference": "DeleteKeyword" } } } + } + ] + }, + { + "name": "FunctionCallExpression", + "operators": [ + { + "model": "Postfix", + "fields": { "arguments": { "Required": { "reference": "ArgumentsDeclaration" } } } + } + ] + }, + { + "name": "CallOptionsExpression", + "operators": [ + { + "model": "Postfix", + "enabled": { "From": { "from": "0.6.2" } }, + "error_recovery": { + "delimiters": { + "open": "open_brace", + "close": "close_brace", + "terminals_matched_acceptance_threshold": 2 + } + }, + "fields": { + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "options": { "Required": { "reference": "CallOptions" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + ] + }, + { + "name": "MemberAccessExpression", + "operators": [ + { + "model": "Postfix", + "fields": { + "period": { "Required": { "reference": "Period" } }, + "member": { "Required": { "reference": "Identifier" } } + } + } + ] + }, + { + "name": "IndexAccessExpression", + "operators": [ + { + "model": "Postfix", + "error_recovery": { "delimiters": { "open": "open_bracket", "close": "close_bracket" } }, + "fields": { + "open_bracket": { "Required": { "reference": "OpenBracket" } }, + "start": { "Optional": { "reference": "Expression" } }, + "end": { "Optional": { "reference": "IndexAccessEnd" } }, + "close_bracket": { "Required": { "reference": "CloseBracket" } } + } + } + ] + } + ], + "primary_expressions": [ + { "reference": "NewExpression" }, + { "reference": "TupleExpression" }, + { "reference": "TypeExpression", "enabled": { "From": { "from": "0.5.3" } } }, + { "reference": "ArrayExpression" }, + { "reference": "HexNumberExpression" }, + { "reference": "DecimalNumberExpression" }, + { "reference": "StringExpression" }, + { "reference": "ElementaryType" }, + { "reference": "PayableKeyword", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "ThisKeyword" }, + { "reference": "SuperKeyword" }, + { "reference": "TrueKeyword" }, + { "reference": "FalseKeyword" }, + { "reference": "Identifier" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "IndexAccessEnd", + "fields": { + "colon": { "Required": { "reference": "Colon" } }, + "end": { "Optional": { "reference": "Expression" } } + } + } + } + } + ] + }, + { + "title": "Function Calls", + "items": [ + { + "Enum": { + "item": { + "name": "ArgumentsDeclaration", + "variants": [ + { "reference": "PositionalArgumentsDeclaration" }, + { "reference": "NamedArgumentsDeclaration" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "PositionalArgumentsDeclaration", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "arguments": { "Required": { "reference": "PositionalArguments" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { + "Separated": { + "item": { + "name": "PositionalArguments", + "reference": "Expression", + "separator": "Comma", + "allow_empty": true + } + } + }, + { + "Struct": { + "item": { + "name": "NamedArgumentsDeclaration", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "arguments": { "Optional": { "reference": "NamedArgumentGroup" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "NamedArgumentGroup", + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "arguments": { "Required": { "reference": "NamedArguments" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + } + }, + { + "Separated": { + "item": { + "name": "NamedArguments", + "reference": "NamedArgument", + "separator": "Comma", + "allow_empty": true + } + } + }, + { + "Separated": { + "item": { + "name": "CallOptions", + "reference": "NamedArgument", + "separator": "Comma", + "enabled": { "From": { "from": "0.6.2" } }, + "allow_empty": false + } + } + }, + { + "Struct": { + "item": { + "name": "NamedArgument", + "fields": { + "name": { "Required": { "reference": "Identifier" } }, + "colon": { "Required": { "reference": "Colon" } }, + "value": { "Required": { "reference": "Expression" } } + } + } + } + } + ] + }, + { + "title": "Primary Expressions", + "items": [ + { + "Struct": { + "item": { + "name": "TypeExpression", + "enabled": { "From": { "from": "0.5.3" } }, + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "type_keyword": { "Required": { "reference": "TypeKeyword" } }, + "open_paren": { "Required": { "reference": "OpenParen" } }, + "type_name": { "Required": { "reference": "TypeName" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "NewExpression", + "fields": { + "new_keyword": { "Required": { "reference": "NewKeyword" } }, + "type_name": { "Required": { "reference": "TypeName" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "TupleExpression", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "items": { "Required": { "reference": "TupleValues" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { "Separated": { "item": { "name": "TupleValues", "reference": "TupleValue", "separator": "Comma" } } }, + { + "Struct": { + "item": { + "name": "TupleValue", + "fields": { "expression": { "Optional": { "reference": "Expression" } } } + } + } + }, + { + "Struct": { + "item": { + "name": "ArrayExpression", + "error_recovery": { "delimiters": { "open": "open_bracket", "close": "close_bracket" } }, + "fields": { + "open_bracket": { "Required": { "reference": "OpenBracket" } }, + "items": { "Required": { "reference": "ArrayValues" } }, + "close_bracket": { "Required": { "reference": "CloseBracket" } } + } + } + } + }, + { "Separated": { "item": { "name": "ArrayValues", "reference": "Expression", "separator": "Comma" } } } + ] + }, + { + "title": "Numbers", + "items": [ + { + "Struct": { + "item": { + "name": "HexNumberExpression", + "fields": { + "literal": { "Required": { "reference": "HexLiteral" } }, + "unit": { "Optional": { "reference": "NumberUnit", "enabled": { "Till": { "till": "0.5.0" } } } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "DecimalNumberExpression", + "fields": { + "literal": { "Required": { "reference": "DecimalLiteral" } }, + "unit": { "Optional": { "reference": "NumberUnit" } } + } + } + } + }, + { + "Token": { + "item": { + "name": "HexLiteral", + "definitions": [ + { + "scanner": { + "TrailingContext": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "0x" } }, + { "OneOrMore": { "scanner": { "Fragment": { "reference": "HexCharacter" } } } }, + { + "ZeroOrMore": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "_" } }, + { + "OneOrMore": { "scanner": { "Fragment": { "reference": "HexCharacter" } } } + } + ] + } + } + } + } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "IdentifierStart" } } + } + } + }, + { + "enabled": { "Till": { "till": "0.5.0" } }, + "scanner": { + "TrailingContext": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "0X" } }, + { "OneOrMore": { "scanner": { "Fragment": { "reference": "HexCharacter" } } } }, + { + "ZeroOrMore": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "_" } }, + { + "OneOrMore": { "scanner": { "Fragment": { "reference": "HexCharacter" } } } + } + ] + } + } + } + } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "IdentifierStart" } } + } + } + } + ] + } + } + }, + { + "Token": { + "item": { + "name": "DecimalLiteral", + "definitions": [ + { + "scanner": { + "TrailingContext": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "." } }, + { "Fragment": { "reference": "DecimalDigits" } }, + { "Optional": { "scanner": { "Fragment": { "reference": "DecimalExponent" } } } } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "IdentifierStart" } } + } + } + }, + { + "scanner": { + "TrailingContext": { + "scanner": { + "Sequence": { + "scanners": [ + { + "TrailingContext": { + "scanner": { "Fragment": { "reference": "DecimalDigits" } }, + "not_followed_by": { "Atom": { "atom": "." } } + } + }, + { "Optional": { "scanner": { "Fragment": { "reference": "DecimalExponent" } } } } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "IdentifierStart" } } + } + } + }, + { + "enabled": { "Till": { "till": "0.5.0" } }, + "scanner": { + "TrailingContext": { + "scanner": { + "Sequence": { + "scanners": [ + { + "TrailingContext": { + "scanner": { + "Sequence": { + "scanners": [ + { "Fragment": { "reference": "DecimalDigits" } }, + { "Atom": { "atom": "." } } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "DecimalDigits" } } + } + }, + { "Optional": { "scanner": { "Fragment": { "reference": "DecimalExponent" } } } } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "IdentifierStart" } } + } + } + }, + { + "enabled": { "Till": { "till": "0.5.0" } }, + "scanner": { + "TrailingContext": { + "scanner": { + "Sequence": { + "scanners": [ + { "Fragment": { "reference": "DecimalDigits" } }, + { "Atom": { "atom": "." } }, + { "Fragment": { "reference": "DecimalDigits" } }, + { "Optional": { "scanner": { "Fragment": { "reference": "DecimalExponent" } } } } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "IdentifierStart" } } + } + } + }, + { + "enabled": { "From": { "from": "0.5.0" } }, + "scanner": { + "TrailingContext": { + "scanner": { + "Sequence": { + "scanners": [ + { "Fragment": { "reference": "DecimalDigits" } }, + { + "Optional": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "." } }, + { "Fragment": { "reference": "DecimalDigits" } } + ] + } + } + } + }, + { "Optional": { "scanner": { "Fragment": { "reference": "DecimalExponent" } } } } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "IdentifierStart" } } + } + } + } + ] + } + } + }, + { + "Fragment": { + "item": { + "name": "DecimalDigits", + "scanner": { + "Sequence": { + "scanners": [ + { "OneOrMore": { "scanner": { "Range": { "inclusive_start": "0", "inclusive_end": "9" } } } }, + { + "ZeroOrMore": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "_" } }, + { + "OneOrMore": { + "scanner": { "Range": { "inclusive_start": "0", "inclusive_end": "9" } } + } + } + ] + } + } + } + } + ] + } + } + } + } + }, + { + "Fragment": { + "item": { + "name": "DecimalExponent", + "scanner": { + "Sequence": { + "scanners": [ + { "Choice": { "scanners": [{ "Atom": { "atom": "e" } }, { "Atom": { "atom": "E" } }] } }, + { "Optional": { "scanner": { "Atom": { "atom": "-" } } } }, + { "Fragment": { "reference": "DecimalDigits" } } + ] + } + } + } + } + }, + { + "Enum": { + "item": { + "name": "NumberUnit", + "variants": [ + { "reference": "WeiKeyword" }, + { "reference": "GweiKeyword", "enabled": { "From": { "from": "0.6.11" } } }, + { "reference": "SzaboKeyword", "enabled": { "Till": { "till": "0.7.0" } } }, + { "reference": "FinneyKeyword", "enabled": { "Till": { "till": "0.7.0" } } }, + { "reference": "EtherKeyword" }, + { "reference": "SecondsKeyword" }, + { "reference": "MinutesKeyword" }, + { "reference": "HoursKeyword" }, + { "reference": "DaysKeyword" }, + { "reference": "WeeksKeyword" }, + { "reference": "YearsKeyword", "enabled": { "Till": { "till": "0.5.0" } } } + ] + } + } + } + ] + }, + { + "title": "Strings", + "items": [ + { + "Enum": { + "item": { + "name": "StringExpression", + "variants": [ + { "reference": "StringLiteral", "enabled": { "Till": { "till": "0.5.14" } } }, + { "reference": "StringLiterals", "enabled": { "From": { "from": "0.5.14" } } }, + { "reference": "HexStringLiteral", "enabled": { "Till": { "till": "0.5.14" } } }, + { "reference": "HexStringLiterals", "enabled": { "From": { "from": "0.5.14" } } }, + { "reference": "UnicodeStringLiterals", "enabled": { "From": { "from": "0.7.0" } } } + ] + } + } + }, + { + "Repeated": { + "item": { + "name": "StringLiterals", + "reference": "StringLiteral", + "enabled": { "From": { "from": "0.5.14" } } + } + } + }, + { + "Enum": { + "item": { + "name": "StringLiteral", + "variants": [ + { "reference": "SingleQuotedStringLiteral" }, + { "reference": "DoubleQuotedStringLiteral" } + ] + } + } + }, + { + "Token": { + "item": { + "name": "SingleQuotedStringLiteral", + "definitions": [ + { + "enabled": { "Till": { "till": "0.4.25" } }, + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "'" } }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "EscapeSequenceArbitrary" } }, + { "Not": { "chars": ["'", "\\", "\r", "\n"] } } + ] + } + } + } + }, + { "Atom": { "atom": "'" } } + ] + } + } + }, + { + "enabled": { "Range": { "from": "0.4.25", "till": "0.7.0" } }, + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "'" } }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "EscapeSequence" } }, + { "Not": { "chars": ["'", "\\", "\r", "\n"] } } + ] + } + } + } + }, + { "Atom": { "atom": "'" } } + ] + } + } + }, + { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "'" } }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "EscapeSequence" } }, + { "Range": { "inclusive_start": " ", "inclusive_end": "&" } }, + { "Range": { "inclusive_start": "(", "inclusive_end": "[" } }, + { "Range": { "inclusive_start": "]", "inclusive_end": "~" } } + ] + } + } + } + }, + { "Atom": { "atom": "'" } } + ] + } + } + } + ] + } + } + }, + { + "Token": { + "item": { + "name": "DoubleQuotedStringLiteral", + "definitions": [ + { + "enabled": { "Till": { "till": "0.4.25" } }, + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "\"" } }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "EscapeSequenceArbitrary" } }, + { "Not": { "chars": ["\"", "\\", "\r", "\n"] } } + ] + } + } + } + }, + { "Atom": { "atom": "\"" } } + ] + } + } + }, + { + "enabled": { "Range": { "from": "0.4.25", "till": "0.7.0" } }, + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "\"" } }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "EscapeSequence" } }, + { "Not": { "chars": ["\"", "\\", "\r", "\n"] } } + ] + } + } + } + }, + { "Atom": { "atom": "\"" } } + ] + } + } + }, + { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "\"" } }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "EscapeSequence" } }, + { "Range": { "inclusive_start": " ", "inclusive_end": "!" } }, + { "Range": { "inclusive_start": "#", "inclusive_end": "[" } }, + { "Range": { "inclusive_start": "]", "inclusive_end": "~" } } + ] + } + } + } + }, + { "Atom": { "atom": "\"" } } + ] + } + } + } + ] + } + } + }, + { + "Repeated": { + "item": { + "name": "HexStringLiterals", + "reference": "HexStringLiteral", + "enabled": { "From": { "from": "0.5.14" } } + } + } + }, + { + "Enum": { + "item": { + "name": "HexStringLiteral", + "variants": [ + { "reference": "SingleQuotedHexStringLiteral" }, + { "reference": "DoubleQuotedHexStringLiteral" } + ] + } + } + }, + { + "Token": { + "item": { + "name": "SingleQuotedHexStringLiteral", + "definitions": [ + { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "hex'" } }, + { "Optional": { "scanner": { "Fragment": { "reference": "HexStringContents" } } } }, + { "Atom": { "atom": "'" } } + ] + } + } + } + ] + } + } + }, + { + "Token": { + "item": { + "name": "DoubleQuotedHexStringLiteral", + "definitions": [ + { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "hex\"" } }, + { "Optional": { "scanner": { "Fragment": { "reference": "HexStringContents" } } } }, + { "Atom": { "atom": "\"" } } + ] + } + } + } + ] + } + } + }, + { + "Fragment": { + "item": { + "name": "HexStringContents", + "scanner": { + "Sequence": { + "scanners": [ + { "Fragment": { "reference": "HexCharacter" } }, + { "Fragment": { "reference": "HexCharacter" } }, + { + "ZeroOrMore": { + "scanner": { + "Sequence": { + "scanners": [ + { "Optional": { "scanner": { "Atom": { "atom": "_" } } } }, + { "Fragment": { "reference": "HexCharacter" } }, + { "Fragment": { "reference": "HexCharacter" } } + ] + } + } + } + } + ] + } + } + } + } + }, + { + "Fragment": { + "item": { + "name": "HexCharacter", + "scanner": { + "Choice": { + "scanners": [ + { "Range": { "inclusive_start": "0", "inclusive_end": "9" } }, + { "Range": { "inclusive_start": "a", "inclusive_end": "f" } }, + { "Range": { "inclusive_start": "A", "inclusive_end": "F" } } + ] + } + } + } + } + }, + { + "Repeated": { + "item": { + "name": "UnicodeStringLiterals", + "reference": "UnicodeStringLiteral", + "enabled": { "From": { "from": "0.7.0" } } + } + } + }, + { + "Enum": { + "item": { + "name": "UnicodeStringLiteral", + "enabled": { "From": { "from": "0.7.0" } }, + "variants": [ + { "reference": "SingleQuotedUnicodeStringLiteral" }, + { "reference": "DoubleQuotedUnicodeStringLiteral" } + ] + } + } + }, + { + "Token": { + "item": { + "name": "SingleQuotedUnicodeStringLiteral", + "definitions": [ + { + "enabled": { "From": { "from": "0.7.0" } }, + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "unicode'" } }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "EscapeSequence" } }, + { "Not": { "chars": ["'", "\\", "\r", "\n"] } } + ] + } + } + } + }, + { "Atom": { "atom": "'" } } + ] + } + } + } + ] + } + } + }, + { + "Token": { + "item": { + "name": "DoubleQuotedUnicodeStringLiteral", + "definitions": [ + { + "enabled": { "From": { "from": "0.7.0" } }, + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "unicode\"" } }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "EscapeSequence" } }, + { "Not": { "chars": ["\"", "\\", "\r", "\n"] } } + ] + } + } + } + }, + { "Atom": { "atom": "\"" } } + ] + } + } + } + ] + } + } + }, + { + "Fragment": { + "item": { + "name": "EscapeSequence", + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "\\" } }, + { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "AsciiEscape" } }, + { "Fragment": { "reference": "HexByteEscape" } }, + { "Fragment": { "reference": "UnicodeEscape" } } + ] + } + } + ] + } + } + } + } + }, + { + "Fragment": { + "item": { + "name": "EscapeSequenceArbitrary", + "enabled": { "Till": { "till": "0.4.25" } }, + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "\\" } }, + { + "Choice": { + "scanners": [ + { "Not": { "chars": ["x", "u"] } }, + { "Fragment": { "reference": "HexByteEscape" } }, + { "Fragment": { "reference": "UnicodeEscape" } } + ] + } + } + ] + } + } + } + } + }, + { + "Fragment": { + "item": { + "name": "AsciiEscape", + "scanner": { + "Choice": { + "scanners": [ + { "Atom": { "atom": "n" } }, + { "Atom": { "atom": "r" } }, + { "Atom": { "atom": "t" } }, + { "Atom": { "atom": "'" } }, + { "Atom": { "atom": "\"" } }, + { "Atom": { "atom": "\\" } }, + { "Atom": { "atom": "\r\n" } }, + { "Atom": { "atom": "\r" } }, + { "Atom": { "atom": "\n" } } + ] + } + } + } + } + }, + { + "Fragment": { + "item": { + "name": "HexByteEscape", + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "x" } }, + { "Fragment": { "reference": "HexCharacter" } }, + { "Fragment": { "reference": "HexCharacter" } } + ] + } + } + } + } + }, + { + "Fragment": { + "item": { + "name": "UnicodeEscape", + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "u" } }, + { "Fragment": { "reference": "HexCharacter" } }, + { "Fragment": { "reference": "HexCharacter" } }, + { "Fragment": { "reference": "HexCharacter" } }, + { "Fragment": { "reference": "HexCharacter" } } + ] + } + } + } + } + } + ] + }, + { + "title": "Identifiers", + "items": [ + { "Separated": { "item": { "name": "IdentifierPath", "reference": "Identifier", "separator": "Period" } } }, + { + "Token": { + "item": { + "name": "Identifier", + "definitions": [ + { + "scanner": { + "Sequence": { + "scanners": [ + { "Fragment": { "reference": "IdentifierStart" } }, + { "ZeroOrMore": { "scanner": { "Fragment": { "reference": "IdentifierPart" } } } } + ] + } + } + } + ] + } + } + }, + { + "Fragment": { + "item": { + "name": "IdentifierStart", + "scanner": { + "Choice": { + "scanners": [ + { "Atom": { "atom": "_" } }, + { "Atom": { "atom": "$" } }, + { "Range": { "inclusive_start": "a", "inclusive_end": "z" } }, + { "Range": { "inclusive_start": "A", "inclusive_end": "Z" } } + ] + } + } + } + } + }, + { + "Fragment": { + "item": { + "name": "IdentifierPart", + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "IdentifierStart" } }, + { "Range": { "inclusive_start": "0", "inclusive_end": "9" } } + ] + } + } + } + } + } + ] + } + ] + }, + { + "title": "Yul", + "topics": [ + { + "title": "Yul Statements", + "lexical_context": "Yul", + "items": [ + { + "Struct": { + "item": { + "name": "YulBlock", + "error_recovery": { "delimiters": { "open": "open_brace", "close": "close_brace" } }, + "fields": { + "open_brace": { "Required": { "reference": "OpenBrace" } }, + "statements": { "Required": { "reference": "YulStatements" } }, + "close_brace": { "Required": { "reference": "CloseBrace" } } + } + } + } + }, + { "Repeated": { "item": { "name": "YulStatements", "reference": "YulStatement", "allow_empty": true } } }, + { + "Enum": { + "item": { + "name": "YulStatement", + "variants": [ + { "reference": "YulBlock" }, + { "reference": "YulFunctionDefinition" }, + { "reference": "YulStackAssignmentStatement", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "YulIfStatement" }, + { "reference": "YulForStatement" }, + { "reference": "YulSwitchStatement" }, + { "reference": "YulLeaveStatement", "enabled": { "From": { "from": "0.6.0" } } }, + { "reference": "YulBreakStatement" }, + { "reference": "YulContinueStatement" }, + { "reference": "YulVariableAssignmentStatement" }, + { "reference": "YulLabel", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "YulVariableDeclarationStatement" }, + { "reference": "YulExpression" } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "YulFunctionDefinition", + "fields": { + "function_keyword": { "Required": { "reference": "YulFunctionKeyword" } }, + "name": { "Required": { "reference": "YulIdentifier" } }, + "parameters": { "Required": { "reference": "YulParametersDeclaration" } }, + "returns": { "Optional": { "reference": "YulReturnsDeclaration" } }, + "body": { "Required": { "reference": "YulBlock" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "YulParametersDeclaration", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "parameters": { "Required": { "reference": "YulParameters" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + } + }, + { + "Separated": { + "item": { + "name": "YulParameters", + "reference": "YulIdentifier", + "separator": "Comma", + "allow_empty": true + } + } + }, + { + "Struct": { + "item": { + "name": "YulReturnsDeclaration", + "fields": { + "minus_greater_than": { "Required": { "reference": "MinusGreaterThan" } }, + "variables": { "Required": { "reference": "YulVariableNames" } } + } + } + } + }, + { + "Separated": { + "item": { "name": "YulVariableNames", "reference": "YulIdentifier", "separator": "Comma" } + } + }, + { + "Struct": { + "item": { + "name": "YulVariableDeclarationStatement", + "fields": { + "let_keyword": { "Required": { "reference": "YulLetKeyword" } }, + "variables": { "Required": { "reference": "YulVariableNames" } }, + "value": { "Optional": { "reference": "YulVariableDeclarationValue" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "YulVariableDeclarationValue", + "fields": { + "assignment": { "Required": { "reference": "YulAssignmentOperator" } }, + "expression": { "Required": { "reference": "YulExpression" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "YulVariableAssignmentStatement", + "fields": { + "variables": { "Required": { "reference": "YulPaths" } }, + "assignment": { "Required": { "reference": "YulAssignmentOperator" } }, + "expression": { "Required": { "reference": "YulExpression" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "YulAssignmentOperator", + "variants": [ + { "reference": "ColonEqual" }, + { "reference": "YulColonAndEqual", "enabled": { "Till": { "till": "0.5.5" } } } + ] + } + } + }, + { + "Struct": { + "item": { + "name": "YulColonAndEqual", + "enabled": { "Till": { "till": "0.5.5" } }, + "fields": { + "colon": { "Required": { "reference": "Colon" } }, + "equal": { "Required": { "reference": "Equal" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "YulStackAssignmentStatement", + "enabled": { "Till": { "till": "0.5.0" } }, + "fields": { + "assignment": { "Required": { "reference": "YulStackAssignmentOperator" } }, + "variable": { "Required": { "reference": "YulIdentifier" } } + } + } + } + }, + { + "Enum": { + "item": { + "name": "YulStackAssignmentOperator", + "enabled": { "Till": { "till": "0.5.0" } }, + "variants": [{ "reference": "EqualColon" }, { "reference": "YulEqualAndColon" }] + } + } + }, + { + "Struct": { + "item": { + "name": "YulEqualAndColon", + "enabled": { "Till": { "till": "0.5.0" } }, + "fields": { + "equal": { "Required": { "reference": "Equal" } }, + "colon": { "Required": { "reference": "Colon" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "YulIfStatement", + "fields": { + "if_keyword": { "Required": { "reference": "YulIfKeyword" } }, + "condition": { "Required": { "reference": "YulExpression" } }, + "body": { "Required": { "reference": "YulBlock" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "YulForStatement", + "fields": { + "for_keyword": { "Required": { "reference": "YulForKeyword" } }, + "initialization": { "Required": { "reference": "YulBlock" } }, + "condition": { "Required": { "reference": "YulExpression" } }, + "iterator": { "Required": { "reference": "YulBlock" } }, + "body": { "Required": { "reference": "YulBlock" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "YulSwitchStatement", + "fields": { + "switch_keyword": { "Required": { "reference": "YulSwitchKeyword" } }, + "expression": { "Required": { "reference": "YulExpression" } }, + "cases": { "Required": { "reference": "YulSwitchCases" } } + } + } + } + }, + { "Repeated": { "item": { "name": "YulSwitchCases", "reference": "YulSwitchCase" } } }, + { + "Enum": { + "item": { + "name": "YulSwitchCase", + "variants": [{ "reference": "YulDefaultCase" }, { "reference": "YulValueCase" }] + } + } + }, + { + "Struct": { + "item": { + "name": "YulDefaultCase", + "fields": { + "default_keyword": { "Required": { "reference": "YulDefaultKeyword" } }, + "body": { "Required": { "reference": "YulBlock" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "YulValueCase", + "fields": { + "case_keyword": { "Required": { "reference": "YulCaseKeyword" } }, + "value": { "Required": { "reference": "YulLiteral" } }, + "body": { "Required": { "reference": "YulBlock" } } + } + } + } + }, + { + "Struct": { + "item": { + "name": "YulLeaveStatement", + "enabled": { "From": { "from": "0.6.0" } }, + "fields": { "leave_keyword": { "Required": { "reference": "YulLeaveKeyword" } } } + } + } + }, + { + "Struct": { + "item": { + "name": "YulBreakStatement", + "fields": { "break_keyword": { "Required": { "reference": "YulBreakKeyword" } } } + } + } + }, + { + "Struct": { + "item": { + "name": "YulContinueStatement", + "fields": { "continue_keyword": { "Required": { "reference": "YulContinueKeyword" } } } + } + } + }, + { + "Struct": { + "item": { + "name": "YulLabel", + "enabled": { "Till": { "till": "0.5.0" } }, + "fields": { + "label": { "Required": { "reference": "YulIdentifier" } }, + "colon": { "Required": { "reference": "Colon" } } + } + } + } + } + ] + }, + { + "title": "Yul Expressions", + "lexical_context": "Yul", + "items": [ + { + "Precedence": { + "item": { + "name": "YulExpression", + "precedence_expressions": [ + { + "name": "YulFunctionCallExpression", + "operators": [ + { + "model": "Postfix", + "error_recovery": { "delimiters": { "open": "open_paren", "close": "close_paren" } }, + "fields": { + "open_paren": { "Required": { "reference": "OpenParen" } }, + "arguments": { "Required": { "reference": "YulArguments" } }, + "close_paren": { "Required": { "reference": "CloseParen" } } + } + } + ] + } + ], + "primary_expressions": [ + { "reference": "YulLiteral" }, + { "reference": "YulBuiltInFunction" }, + { "reference": "YulPath" } + ] + } + } + }, + { + "Separated": { + "item": { + "name": "YulArguments", + "reference": "YulExpression", + "separator": "Comma", + "allow_empty": true + } + } + }, + { "Separated": { "item": { "name": "YulPaths", "reference": "YulPath", "separator": "Comma" } } }, + { "Separated": { "item": { "name": "YulPath", "reference": "YulIdentifier", "separator": "Period" } } }, + { + "Token": { + "item": { + "name": "YulIdentifier", + "definitions": [ + { + "enabled": { "Range": { "from": "0.5.8", "till": "0.7.0" } }, + "scanner": { + "Sequence": { + "scanners": [ + { "Fragment": { "reference": "IdentifierStart" } }, + { + "ZeroOrMore": { + "scanner": { + "Choice": { + "scanners": [ + { "Fragment": { "reference": "IdentifierPart" } }, + { "Atom": { "atom": "." } } + ] + } + } + } + } + ] + } + } + }, + { + "scanner": { + "Sequence": { + "scanners": [ + { "Fragment": { "reference": "IdentifierStart" } }, + { "ZeroOrMore": { "scanner": { "Fragment": { "reference": "IdentifierPart" } } } } + ] + } + } + } + ] + } + } + }, + { + "Enum": { + "item": { + "name": "YulBuiltInFunction", + "variants": [ + { "reference": "YulAddKeyword" }, + { "reference": "YulAddModKeyword" }, + { "reference": "YulAddressKeyword" }, + { "reference": "YulAndKeyword" }, + { "reference": "YulBalanceKeyword" }, + { "reference": "YulBlockHashKeyword" }, + { "reference": "YulByteKeyword" }, + { "reference": "YulCallCodeKeyword" }, + { "reference": "YulCallDataCopyKeyword" }, + { "reference": "YulCallDataLoadKeyword" }, + { "reference": "YulCallDataSizeKeyword" }, + { "reference": "YulCallerKeyword" }, + { "reference": "YulCallKeyword" }, + { "reference": "YulCallValueKeyword" }, + { "reference": "YulCoinBaseKeyword" }, + { "reference": "YulCreateKeyword" }, + { "reference": "YulDelegateCallKeyword" }, + { "reference": "YulDivKeyword" }, + { "reference": "YulEqKeyword" }, + { "reference": "YulExpKeyword" }, + { "reference": "YulExtCodeCopyKeyword" }, + { "reference": "YulExtCodeSizeKeyword" }, + { "reference": "YulGasKeyword" }, + { "reference": "YulGasLimitKeyword" }, + { "reference": "YulGasPriceKeyword" }, + { "reference": "YulGtKeyword" }, + { "reference": "YulInvalidKeyword" }, + { "reference": "YulIsZeroKeyword" }, + { "reference": "YulJumpKeyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "YulJumpiKeyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "YulLog0Keyword" }, + { "reference": "YulLog1Keyword" }, + { "reference": "YulLog2Keyword" }, + { "reference": "YulLog3Keyword" }, + { "reference": "YulLog4Keyword" }, + { "reference": "YulLtKeyword" }, + { "reference": "YulMLoadKeyword" }, + { "reference": "YulModKeyword" }, + { "reference": "YulMSizeKeyword" }, + { "reference": "YulMStore8Keyword" }, + { "reference": "YulMStoreKeyword" }, + { "reference": "YulMulKeyword" }, + { "reference": "YulMulModKeyword" }, + { "reference": "YulNotKeyword" }, + { "reference": "YulNumberKeyword" }, + { "reference": "YulOriginKeyword" }, + { "reference": "YulOrKeyword" }, + { "reference": "YulPopKeyword" }, + { "reference": "YulReturnKeyword" }, + { "reference": "YulRevertKeyword" }, + { "reference": "YulSDivKeyword" }, + { "reference": "YulSelfDestructKeyword" }, + { "reference": "YulSgtKeyword" }, + { "reference": "YulSignExtendKeyword" }, + { "reference": "YulSLoadKeyword" }, + { "reference": "YulSltKeyword" }, + { "reference": "YulSModKeyword" }, + { "reference": "YulSStoreKeyword" }, + { "reference": "YulStopKeyword" }, + { "reference": "YulSubKeyword" }, + { "reference": "YulTimestampKeyword" }, + { "reference": "YulXorKeyword" }, + { "reference": "YulKeccak256Keyword", "enabled": { "From": { "from": "0.4.12" } } }, + { "reference": "YulSha3Keyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "YulSuicideKeyword", "enabled": { "Till": { "till": "0.5.0" } } }, + { "reference": "YulReturnDataCopyKeyword", "enabled": { "From": { "from": "0.4.12" } } }, + { "reference": "YulReturnDataSizeKeyword", "enabled": { "From": { "from": "0.4.12" } } }, + { "reference": "YulStaticCallKeyword", "enabled": { "From": { "from": "0.4.12" } } }, + { "reference": "YulCreate2Keyword", "enabled": { "From": { "from": "0.4.12" } } }, + { "reference": "YulExtCodeHashKeyword", "enabled": { "From": { "from": "0.5.0" } } }, + { "reference": "YulSarKeyword" }, + { "reference": "YulShlKeyword" }, + { "reference": "YulShrKeyword" }, + { "reference": "YulChainIdKeyword" }, + { "reference": "YulSelfBalanceKeyword" }, + { "reference": "YulBaseFeeKeyword", "enabled": { "From": { "from": "0.8.7" } } }, + { "reference": "YulDifficultyKeyword", "enabled": { "Till": { "till": "0.8.18" } } }, + { "reference": "YulPrevRandaoKeyword", "enabled": { "From": { "from": "0.8.18" } } }, + { "reference": "YulBlobBaseFeeKeyword", "enabled": { "From": { "from": "0.8.24" } } }, + { "reference": "YulBlobHashKeyword", "enabled": { "From": { "from": "0.8.24" } } }, + { "reference": "YulTLoadKeyword", "enabled": { "From": { "from": "0.8.24" } } }, + { "reference": "YulTStoreKeyword", "enabled": { "From": { "from": "0.8.24" } } }, + { "reference": "YulMCopyKeyword", "enabled": { "From": { "from": "0.8.24" } } } + ] + } + } + }, + { + "Enum": { + "item": { + "name": "YulLiteral", + "variants": [ + { "reference": "YulTrueKeyword" }, + { "reference": "YulFalseKeyword" }, + { "reference": "YulDecimalLiteral" }, + { "reference": "YulHexLiteral" }, + { "reference": "HexStringLiteral" }, + { "reference": "StringLiteral" } + ] + } + } + }, + { + "Token": { + "item": { + "name": "YulDecimalLiteral", + "definitions": [ + { + "scanner": { + "TrailingContext": { + "scanner": { + "Choice": { + "scanners": [ + { "Atom": { "atom": "0" } }, + { + "Sequence": { + "scanners": [ + { "Range": { "inclusive_start": "1", "inclusive_end": "9" } }, + { + "ZeroOrMore": { + "scanner": { "Range": { "inclusive_start": "0", "inclusive_end": "9" } } + } + } + ] + } + } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "IdentifierStart" } } + } + } + } + ] + } + } + }, + { + "Token": { + "item": { + "name": "YulHexLiteral", + "definitions": [ + { + "scanner": { + "TrailingContext": { + "scanner": { + "Sequence": { + "scanners": [ + { "Atom": { "atom": "0x" } }, + { "OneOrMore": { "scanner": { "Fragment": { "reference": "HexCharacter" } } } } + ] + } + }, + "not_followed_by": { "Fragment": { "reference": "IdentifierStart" } } + } + } + } + ] + } + } + } + ] + }, + { + "title": "Yul Keywords", + "lexical_context": "Yul", + "items": [ + { + "Keyword": { + "item": { + "name": "YulAbstractKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "abstract" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAddKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "add" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAddModKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "addmod" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAddressKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "reserved": "Never", "value": { "Atom": { "atom": "address" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAfterKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "after" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAliasKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "alias" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAndKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "and" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAnonymousKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "anonymous" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulApplyKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "apply" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAsKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "as" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAssemblyKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "assembly" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulAutoKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "auto" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulBalanceKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "balance" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulBaseFeeKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.7" } }, + "reserved": { "From": { "from": "0.8.7" } }, + "value": { "Atom": { "atom": "basefee" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulBlobBaseFeeKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.24" } }, + "reserved": { "From": { "from": "0.8.25" } }, + "value": { "Atom": { "atom": "blobbasefee" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulBlobHashKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.24" } }, + "reserved": { "From": { "from": "0.8.25" } }, + "value": { "Atom": { "atom": "blobhash" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulBlockHashKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "blockhash" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulBoolKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.5.10" } }, + "value": { "Atom": { "atom": "bool" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulBreakKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "break" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulByteKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "byte" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulBytesKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "bytes" } }, + { + "Optional": { + "value": { + "Choice": { + "values": [ + { "Atom": { "atom": "1" } }, + { "Atom": { "atom": "2" } }, + { "Atom": { "atom": "3" } }, + { "Atom": { "atom": "4" } }, + { "Atom": { "atom": "5" } }, + { "Atom": { "atom": "6" } }, + { "Atom": { "atom": "7" } }, + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "9" } }, + { "Atom": { "atom": "10" } }, + { "Atom": { "atom": "11" } }, + { "Atom": { "atom": "12" } }, + { "Atom": { "atom": "13" } }, + { "Atom": { "atom": "14" } }, + { "Atom": { "atom": "15" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "17" } }, + { "Atom": { "atom": "18" } }, + { "Atom": { "atom": "19" } }, + { "Atom": { "atom": "20" } }, + { "Atom": { "atom": "21" } }, + { "Atom": { "atom": "22" } }, + { "Atom": { "atom": "23" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "25" } }, + { "Atom": { "atom": "26" } }, + { "Atom": { "atom": "27" } }, + { "Atom": { "atom": "28" } }, + { "Atom": { "atom": "29" } }, + { "Atom": { "atom": "30" } }, + { "Atom": { "atom": "31" } }, + { "Atom": { "atom": "32" } } + ] + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCallCodeKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "callcode" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCallDataCopyKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "calldatacopy" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCallDataKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "calldata" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCallDataLoadKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "calldataload" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCallDataSizeKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "calldatasize" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCallerKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "caller" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCallKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "call" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCallValueKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "callvalue" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCaseKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "case" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCatchKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "catch" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulChainIdKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { "reserved": { "From": { "from": "0.5.12" } }, "value": { "Atom": { "atom": "chainid" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCoinBaseKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "coinbase" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulConstantKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "constant" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulConstructorKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "constructor" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulContinueKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "continue" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulContractKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "contract" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCopyOfKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "copyof" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCreateKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "create" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulCreate2Keyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.4.12" } }, + "reserved": { "From": { "from": "0.4.12" } }, + "value": { "Atom": { "atom": "create2" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulDaysKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "days" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulDefaultKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "default" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulDefineKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "define" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulDelegateCallKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "delegatecall" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulDeleteKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "delete" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulDifficultyKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { "enabled": { "Till": { "till": "0.8.18" } }, "value": { "Atom": { "atom": "difficulty" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulDivKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "div" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulDoKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "do" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulElseKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "else" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulEmitKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "emit" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulEnumKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "enum" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulEqKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "eq" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulEtherKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "ether" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulEventKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "event" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulExpKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "exp" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulExtCodeCopyKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "extcodecopy" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulExtCodeHashKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.5.0" } }, + "reserved": { "From": { "from": "0.5.0" } }, + "value": { "Atom": { "atom": "extcodehash" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulExtCodeSizeKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "extcodesize" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulExternalKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "external" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulFallbackKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.6.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "fallback" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulFalseKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "false" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulFinalKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "final" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulFinneyKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.0" } }, + "value": { "Atom": { "atom": "finney" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulFixedKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "fixed" } } + }, + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "fixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } } + ] + } + }, + { "Atom": { "atom": "x" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } } + ] + } + } + ] + } + } + }, + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "fixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "184x8" } }, + { "Atom": { "atom": "184x16" } }, + { "Atom": { "atom": "184x24" } }, + { "Atom": { "atom": "184x32" } }, + { "Atom": { "atom": "184x40" } }, + { "Atom": { "atom": "184x48" } }, + { "Atom": { "atom": "184x56" } }, + { "Atom": { "atom": "184x64" } }, + { "Atom": { "atom": "184x72" } }, + { "Atom": { "atom": "192x8" } }, + { "Atom": { "atom": "192x16" } }, + { "Atom": { "atom": "192x24" } }, + { "Atom": { "atom": "192x32" } }, + { "Atom": { "atom": "192x40" } }, + { "Atom": { "atom": "192x48" } }, + { "Atom": { "atom": "192x56" } }, + { "Atom": { "atom": "192x64" } }, + { "Atom": { "atom": "200x8" } }, + { "Atom": { "atom": "200x16" } }, + { "Atom": { "atom": "200x24" } }, + { "Atom": { "atom": "200x32" } }, + { "Atom": { "atom": "200x40" } }, + { "Atom": { "atom": "200x48" } }, + { "Atom": { "atom": "200x56" } }, + { "Atom": { "atom": "208x8" } }, + { "Atom": { "atom": "208x16" } }, + { "Atom": { "atom": "208x24" } }, + { "Atom": { "atom": "208x32" } }, + { "Atom": { "atom": "208x40" } }, + { "Atom": { "atom": "208x48" } }, + { "Atom": { "atom": "216x8" } }, + { "Atom": { "atom": "216x16" } }, + { "Atom": { "atom": "216x24" } }, + { "Atom": { "atom": "216x32" } }, + { "Atom": { "atom": "216x40" } }, + { "Atom": { "atom": "224x8" } }, + { "Atom": { "atom": "224x16" } }, + { "Atom": { "atom": "224x24" } }, + { "Atom": { "atom": "224x32" } }, + { "Atom": { "atom": "232x8" } }, + { "Atom": { "atom": "232x16" } }, + { "Atom": { "atom": "232x24" } }, + { "Atom": { "atom": "240x8" } }, + { "Atom": { "atom": "240x16" } }, + { "Atom": { "atom": "248x8" } } + ] + } + } + ] + } + } + }, + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.4.14", "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "fixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "184x80" } }, + { "Atom": { "atom": "192x72" } }, + { "Atom": { "atom": "192x80" } }, + { "Atom": { "atom": "200x64" } }, + { "Atom": { "atom": "200x72" } }, + { "Atom": { "atom": "200x80" } }, + { "Atom": { "atom": "208x56" } }, + { "Atom": { "atom": "208x64" } }, + { "Atom": { "atom": "208x72" } }, + { "Atom": { "atom": "208x80" } }, + { "Atom": { "atom": "216x48" } }, + { "Atom": { "atom": "216x56" } }, + { "Atom": { "atom": "216x64" } }, + { "Atom": { "atom": "216x72" } }, + { "Atom": { "atom": "216x80" } }, + { "Atom": { "atom": "224x40" } }, + { "Atom": { "atom": "224x48" } }, + { "Atom": { "atom": "224x56" } }, + { "Atom": { "atom": "224x64" } }, + { "Atom": { "atom": "224x72" } }, + { "Atom": { "atom": "224x80" } }, + { "Atom": { "atom": "232x32" } }, + { "Atom": { "atom": "232x40" } }, + { "Atom": { "atom": "232x48" } }, + { "Atom": { "atom": "232x56" } }, + { "Atom": { "atom": "232x64" } }, + { "Atom": { "atom": "232x72" } }, + { "Atom": { "atom": "232x80" } }, + { "Atom": { "atom": "240x24" } }, + { "Atom": { "atom": "240x32" } }, + { "Atom": { "atom": "240x40" } }, + { "Atom": { "atom": "240x48" } }, + { "Atom": { "atom": "240x56" } }, + { "Atom": { "atom": "240x64" } }, + { "Atom": { "atom": "240x72" } }, + { "Atom": { "atom": "240x80" } }, + { "Atom": { "atom": "248x16" } }, + { "Atom": { "atom": "248x24" } }, + { "Atom": { "atom": "248x32" } }, + { "Atom": { "atom": "248x40" } }, + { "Atom": { "atom": "248x48" } }, + { "Atom": { "atom": "248x56" } }, + { "Atom": { "atom": "248x64" } }, + { "Atom": { "atom": "248x72" } }, + { "Atom": { "atom": "248x80" } }, + { "Atom": { "atom": "256x8" } }, + { "Atom": { "atom": "256x16" } }, + { "Atom": { "atom": "256x24" } }, + { "Atom": { "atom": "256x32" } }, + { "Atom": { "atom": "256x40" } }, + { "Atom": { "atom": "256x48" } }, + { "Atom": { "atom": "256x56" } }, + { "Atom": { "atom": "256x64" } }, + { "Atom": { "atom": "256x72" } }, + { "Atom": { "atom": "256x80" } } + ] + } + } + ] + } + } + }, + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.4.14", "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "fixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } }, + { "Atom": { "atom": "184" } }, + { "Atom": { "atom": "192" } }, + { "Atom": { "atom": "200" } }, + { "Atom": { "atom": "208" } }, + { "Atom": { "atom": "216" } }, + { "Atom": { "atom": "224" } }, + { "Atom": { "atom": "232" } }, + { "Atom": { "atom": "240" } }, + { "Atom": { "atom": "248" } }, + { "Atom": { "atom": "256" } } + ] + } + }, + { "Atom": { "atom": "x" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "0" } }, + { "Atom": { "atom": "1" } }, + { "Atom": { "atom": "2" } }, + { "Atom": { "atom": "3" } }, + { "Atom": { "atom": "4" } }, + { "Atom": { "atom": "5" } }, + { "Atom": { "atom": "6" } }, + { "Atom": { "atom": "7" } }, + { "Atom": { "atom": "9" } }, + { "Atom": { "atom": "10" } }, + { "Atom": { "atom": "11" } }, + { "Atom": { "atom": "12" } }, + { "Atom": { "atom": "13" } }, + { "Atom": { "atom": "14" } }, + { "Atom": { "atom": "15" } }, + { "Atom": { "atom": "17" } }, + { "Atom": { "atom": "18" } }, + { "Atom": { "atom": "19" } }, + { "Atom": { "atom": "20" } }, + { "Atom": { "atom": "21" } }, + { "Atom": { "atom": "22" } }, + { "Atom": { "atom": "23" } }, + { "Atom": { "atom": "25" } }, + { "Atom": { "atom": "26" } }, + { "Atom": { "atom": "27" } }, + { "Atom": { "atom": "28" } }, + { "Atom": { "atom": "29" } }, + { "Atom": { "atom": "30" } }, + { "Atom": { "atom": "31" } }, + { "Atom": { "atom": "33" } }, + { "Atom": { "atom": "34" } }, + { "Atom": { "atom": "35" } }, + { "Atom": { "atom": "36" } }, + { "Atom": { "atom": "37" } }, + { "Atom": { "atom": "38" } }, + { "Atom": { "atom": "39" } }, + { "Atom": { "atom": "41" } }, + { "Atom": { "atom": "42" } }, + { "Atom": { "atom": "43" } }, + { "Atom": { "atom": "44" } }, + { "Atom": { "atom": "45" } }, + { "Atom": { "atom": "46" } }, + { "Atom": { "atom": "47" } }, + { "Atom": { "atom": "49" } }, + { "Atom": { "atom": "50" } }, + { "Atom": { "atom": "51" } }, + { "Atom": { "atom": "52" } }, + { "Atom": { "atom": "53" } }, + { "Atom": { "atom": "54" } }, + { "Atom": { "atom": "55" } }, + { "Atom": { "atom": "57" } }, + { "Atom": { "atom": "58" } }, + { "Atom": { "atom": "59" } }, + { "Atom": { "atom": "60" } }, + { "Atom": { "atom": "61" } }, + { "Atom": { "atom": "62" } }, + { "Atom": { "atom": "63" } }, + { "Atom": { "atom": "65" } }, + { "Atom": { "atom": "66" } }, + { "Atom": { "atom": "67" } }, + { "Atom": { "atom": "68" } }, + { "Atom": { "atom": "69" } }, + { "Atom": { "atom": "70" } }, + { "Atom": { "atom": "71" } }, + { "Atom": { "atom": "73" } }, + { "Atom": { "atom": "74" } }, + { "Atom": { "atom": "75" } }, + { "Atom": { "atom": "76" } }, + { "Atom": { "atom": "77" } }, + { "Atom": { "atom": "78" } }, + { "Atom": { "atom": "79" } } + ] + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulForKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "for" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulFunctionKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "function" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulGasKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "gas" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulGasLimitKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "gaslimit" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulGasPriceKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "gasprice" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulGtKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "gt" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulGweiKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.7.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "gwei" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulHexKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "hex" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulHoursKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "hours" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulIfKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "if" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulImmutableKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "immutable" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulImplementsKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "implements" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulImportKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "import" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulIndexedKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "indexed" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulInKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.6.8" } }, + "value": { "Atom": { "atom": "in" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulInlineKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "inline" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulInterfaceKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "interface" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulInternalKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "internal" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulIntKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "int" } }, + { + "Optional": { + "value": { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } }, + { "Atom": { "atom": "184" } }, + { "Atom": { "atom": "192" } }, + { "Atom": { "atom": "200" } }, + { "Atom": { "atom": "208" } }, + { "Atom": { "atom": "216" } }, + { "Atom": { "atom": "224" } }, + { "Atom": { "atom": "232" } }, + { "Atom": { "atom": "240" } }, + { "Atom": { "atom": "248" } }, + { "Atom": { "atom": "256" } } + ] + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulInvalidKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "invalid" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulIsKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "is" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulIsZeroKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "iszero" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulJumpKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { "enabled": { "Till": { "till": "0.5.0" } }, "value": { "Atom": { "atom": "jump" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulJumpiKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { "enabled": { "Till": { "till": "0.5.0" } }, "value": { "Atom": { "atom": "jumpi" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulKeccak256Keyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.4.12" } }, + "reserved": { "From": { "from": "0.4.12" } }, + "value": { "Atom": { "atom": "keccak256" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulLeaveKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.6.0" } }, + "reserved": { "From": { "from": "0.7.1" } }, + "value": { "Atom": { "atom": "leave" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulLetKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "let" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulLibraryKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "library" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulLog0Keyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "log0" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulLog1Keyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "log1" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulLog2Keyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "log2" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulLog3Keyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "log3" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulLog4Keyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "log4" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulLtKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "lt" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMacroKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "macro" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMappingKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "mapping" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMatchKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "match" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMemoryKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "memory" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMinutesKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "minutes" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMCopyKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.24" } }, + "reserved": { "From": { "from": "0.8.25" } }, + "value": { "Atom": { "atom": "mcopy" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMLoadKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "mload" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulModKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "mod" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulModifierKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "modifier" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMSizeKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "msize" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMStoreKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "mstore" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMStore8Keyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "mstore8" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMulKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "mul" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMulModKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "mulmod" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulMutableKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "mutable" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulNewKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "new" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulNotKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "not" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulNullKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "null" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulNumberKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "number" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulOfKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "of" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulOrKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "or" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulOriginKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "origin" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulOverrideKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "override" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulPartialKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "partial" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulPayableKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "payable" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulPopKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "pop" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulPragmaKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "pragma" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulPrevRandaoKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.18" } }, + "reserved": { "From": { "from": "0.8.18" } }, + "value": { "Atom": { "atom": "prevrandao" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulPrivateKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "private" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulPromiseKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "promise" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulPublicKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "public" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulPureKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "pure" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulReceiveKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.6.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "receive" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulReferenceKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "reference" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulRelocatableKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "relocatable" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulReturnDataCopyKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.4.12" } }, + "reserved": { "From": { "from": "0.4.12" } }, + "value": { "Atom": { "atom": "returndatacopy" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulReturnDataSizeKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.4.12" } }, + "reserved": { "From": { "from": "0.4.12" } }, + "value": { "Atom": { "atom": "returndatasize" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulReturnKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "return" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulReturnsKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "returns" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulRevertKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "revert" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSarKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { "reserved": { "From": { "from": "0.4.21" } }, "value": { "Atom": { "atom": "sar" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSDivKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "sdiv" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSealedKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "sealed" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSecondsKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "seconds" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSelfBalanceKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { "reserved": { "From": { "from": "0.5.12" } }, "value": { "Atom": { "atom": "selfbalance" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSelfDestructKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "selfdestruct" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSgtKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "sgt" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSha3Keyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "Till": { "till": "0.5.0" } }, + "reserved": { "Till": { "till": "0.5.0" } }, + "value": { "Atom": { "atom": "sha3" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulShlKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { "reserved": { "From": { "from": "0.4.21" } }, "value": { "Atom": { "atom": "shl" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulShrKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { "reserved": { "From": { "from": "0.4.21" } }, "value": { "Atom": { "atom": "shr" } } } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSignExtendKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "signextend" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSizeOfKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "sizeof" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSLoadKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "sload" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSltKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "slt" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSModKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "smod" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSStoreKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "sstore" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulStaticCallKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.4.12" } }, + "reserved": { "From": { "from": "0.4.12" } }, + "value": { "Atom": { "atom": "staticcall" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulStaticKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "static" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulStopKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "stop" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulStorageKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "storage" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulStringKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "string" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulStructKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "struct" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSubKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "sub" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSuicideKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "Till": { "till": "0.5.0" } }, + "reserved": { "Till": { "till": "0.5.0" } }, + "value": { "Atom": { "atom": "suicide" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSuperKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "super" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSupportsKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "supports" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSwitchKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "switch" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulSzaboKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.0" } }, + "value": { "Atom": { "atom": "szabo" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulTimestampKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "timestamp" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulThisKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "enabled": "Never", "value": { "Atom": { "atom": "this" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulThrowKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "throw" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulTLoadKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.24" } }, + "reserved": { "From": { "from": "0.8.25" } }, + "value": { "Atom": { "atom": "tload" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulTrueKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "true" } } }] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulTStoreKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": { "From": { "from": "0.8.24" } }, + "reserved": { "From": { "from": "0.8.25" } }, + "value": { "Atom": { "atom": "tstore" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulTryKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "try" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulTypeDefKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "typedef" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulTypeKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "type" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulTypeOfKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "typeof" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulUfixedKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "ufixed" } } + }, + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "ufixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } } + ] + } + }, + { "Atom": { "atom": "x" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } } + ] + } + } + ] + } + } + }, + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "ufixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "184x8" } }, + { "Atom": { "atom": "184x16" } }, + { "Atom": { "atom": "184x24" } }, + { "Atom": { "atom": "184x32" } }, + { "Atom": { "atom": "184x40" } }, + { "Atom": { "atom": "184x48" } }, + { "Atom": { "atom": "184x56" } }, + { "Atom": { "atom": "184x64" } }, + { "Atom": { "atom": "184x72" } }, + { "Atom": { "atom": "192x8" } }, + { "Atom": { "atom": "192x16" } }, + { "Atom": { "atom": "192x24" } }, + { "Atom": { "atom": "192x32" } }, + { "Atom": { "atom": "192x40" } }, + { "Atom": { "atom": "192x48" } }, + { "Atom": { "atom": "192x56" } }, + { "Atom": { "atom": "192x64" } }, + { "Atom": { "atom": "200x8" } }, + { "Atom": { "atom": "200x16" } }, + { "Atom": { "atom": "200x24" } }, + { "Atom": { "atom": "200x32" } }, + { "Atom": { "atom": "200x40" } }, + { "Atom": { "atom": "200x48" } }, + { "Atom": { "atom": "200x56" } }, + { "Atom": { "atom": "208x8" } }, + { "Atom": { "atom": "208x16" } }, + { "Atom": { "atom": "208x24" } }, + { "Atom": { "atom": "208x32" } }, + { "Atom": { "atom": "208x40" } }, + { "Atom": { "atom": "208x48" } }, + { "Atom": { "atom": "216x8" } }, + { "Atom": { "atom": "216x16" } }, + { "Atom": { "atom": "216x24" } }, + { "Atom": { "atom": "216x32" } }, + { "Atom": { "atom": "216x40" } }, + { "Atom": { "atom": "224x8" } }, + { "Atom": { "atom": "224x16" } }, + { "Atom": { "atom": "224x24" } }, + { "Atom": { "atom": "224x32" } }, + { "Atom": { "atom": "232x8" } }, + { "Atom": { "atom": "232x16" } }, + { "Atom": { "atom": "232x24" } }, + { "Atom": { "atom": "240x8" } }, + { "Atom": { "atom": "240x16" } }, + { "Atom": { "atom": "248x8" } } + ] + } + } + ] + } + } + }, + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.4.14", "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "ufixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "184x80" } }, + { "Atom": { "atom": "192x72" } }, + { "Atom": { "atom": "192x80" } }, + { "Atom": { "atom": "200x64" } }, + { "Atom": { "atom": "200x72" } }, + { "Atom": { "atom": "200x80" } }, + { "Atom": { "atom": "208x56" } }, + { "Atom": { "atom": "208x64" } }, + { "Atom": { "atom": "208x72" } }, + { "Atom": { "atom": "208x80" } }, + { "Atom": { "atom": "216x48" } }, + { "Atom": { "atom": "216x56" } }, + { "Atom": { "atom": "216x64" } }, + { "Atom": { "atom": "216x72" } }, + { "Atom": { "atom": "216x80" } }, + { "Atom": { "atom": "224x40" } }, + { "Atom": { "atom": "224x48" } }, + { "Atom": { "atom": "224x56" } }, + { "Atom": { "atom": "224x64" } }, + { "Atom": { "atom": "224x72" } }, + { "Atom": { "atom": "224x80" } }, + { "Atom": { "atom": "232x32" } }, + { "Atom": { "atom": "232x40" } }, + { "Atom": { "atom": "232x48" } }, + { "Atom": { "atom": "232x56" } }, + { "Atom": { "atom": "232x64" } }, + { "Atom": { "atom": "232x72" } }, + { "Atom": { "atom": "232x80" } }, + { "Atom": { "atom": "240x24" } }, + { "Atom": { "atom": "240x32" } }, + { "Atom": { "atom": "240x40" } }, + { "Atom": { "atom": "240x48" } }, + { "Atom": { "atom": "240x56" } }, + { "Atom": { "atom": "240x64" } }, + { "Atom": { "atom": "240x72" } }, + { "Atom": { "atom": "240x80" } }, + { "Atom": { "atom": "248x16" } }, + { "Atom": { "atom": "248x24" } }, + { "Atom": { "atom": "248x32" } }, + { "Atom": { "atom": "248x40" } }, + { "Atom": { "atom": "248x48" } }, + { "Atom": { "atom": "248x56" } }, + { "Atom": { "atom": "248x64" } }, + { "Atom": { "atom": "248x72" } }, + { "Atom": { "atom": "248x80" } }, + { "Atom": { "atom": "256x8" } }, + { "Atom": { "atom": "256x16" } }, + { "Atom": { "atom": "256x24" } }, + { "Atom": { "atom": "256x32" } }, + { "Atom": { "atom": "256x40" } }, + { "Atom": { "atom": "256x48" } }, + { "Atom": { "atom": "256x56" } }, + { "Atom": { "atom": "256x64" } }, + { "Atom": { "atom": "256x72" } }, + { "Atom": { "atom": "256x80" } } + ] + } + } + ] + } + } + }, + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.4.14", "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "ufixed" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } }, + { "Atom": { "atom": "184" } }, + { "Atom": { "atom": "192" } }, + { "Atom": { "atom": "200" } }, + { "Atom": { "atom": "208" } }, + { "Atom": { "atom": "216" } }, + { "Atom": { "atom": "224" } }, + { "Atom": { "atom": "232" } }, + { "Atom": { "atom": "240" } }, + { "Atom": { "atom": "248" } }, + { "Atom": { "atom": "256" } } + ] + } + }, + { "Atom": { "atom": "x" } }, + { + "Choice": { + "values": [ + { "Atom": { "atom": "0" } }, + { "Atom": { "atom": "1" } }, + { "Atom": { "atom": "2" } }, + { "Atom": { "atom": "3" } }, + { "Atom": { "atom": "4" } }, + { "Atom": { "atom": "5" } }, + { "Atom": { "atom": "6" } }, + { "Atom": { "atom": "7" } }, + { "Atom": { "atom": "9" } }, + { "Atom": { "atom": "10" } }, + { "Atom": { "atom": "11" } }, + { "Atom": { "atom": "12" } }, + { "Atom": { "atom": "13" } }, + { "Atom": { "atom": "14" } }, + { "Atom": { "atom": "15" } }, + { "Atom": { "atom": "17" } }, + { "Atom": { "atom": "18" } }, + { "Atom": { "atom": "19" } }, + { "Atom": { "atom": "20" } }, + { "Atom": { "atom": "21" } }, + { "Atom": { "atom": "22" } }, + { "Atom": { "atom": "23" } }, + { "Atom": { "atom": "25" } }, + { "Atom": { "atom": "26" } }, + { "Atom": { "atom": "27" } }, + { "Atom": { "atom": "28" } }, + { "Atom": { "atom": "29" } }, + { "Atom": { "atom": "30" } }, + { "Atom": { "atom": "31" } }, + { "Atom": { "atom": "33" } }, + { "Atom": { "atom": "34" } }, + { "Atom": { "atom": "35" } }, + { "Atom": { "atom": "36" } }, + { "Atom": { "atom": "37" } }, + { "Atom": { "atom": "38" } }, + { "Atom": { "atom": "39" } }, + { "Atom": { "atom": "41" } }, + { "Atom": { "atom": "42" } }, + { "Atom": { "atom": "43" } }, + { "Atom": { "atom": "44" } }, + { "Atom": { "atom": "45" } }, + { "Atom": { "atom": "46" } }, + { "Atom": { "atom": "47" } }, + { "Atom": { "atom": "49" } }, + { "Atom": { "atom": "50" } }, + { "Atom": { "atom": "51" } }, + { "Atom": { "atom": "52" } }, + { "Atom": { "atom": "53" } }, + { "Atom": { "atom": "54" } }, + { "Atom": { "atom": "55" } }, + { "Atom": { "atom": "57" } }, + { "Atom": { "atom": "58" } }, + { "Atom": { "atom": "59" } }, + { "Atom": { "atom": "60" } }, + { "Atom": { "atom": "61" } }, + { "Atom": { "atom": "62" } }, + { "Atom": { "atom": "63" } }, + { "Atom": { "atom": "65" } }, + { "Atom": { "atom": "66" } }, + { "Atom": { "atom": "67" } }, + { "Atom": { "atom": "68" } }, + { "Atom": { "atom": "69" } }, + { "Atom": { "atom": "70" } }, + { "Atom": { "atom": "71" } }, + { "Atom": { "atom": "73" } }, + { "Atom": { "atom": "74" } }, + { "Atom": { "atom": "75" } }, + { "Atom": { "atom": "76" } }, + { "Atom": { "atom": "77" } }, + { "Atom": { "atom": "78" } }, + { "Atom": { "atom": "79" } } + ] + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulUintKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { + "Sequence": { + "values": [ + { "Atom": { "atom": "uint" } }, + { + "Optional": { + "value": { + "Choice": { + "values": [ + { "Atom": { "atom": "8" } }, + { "Atom": { "atom": "16" } }, + { "Atom": { "atom": "24" } }, + { "Atom": { "atom": "32" } }, + { "Atom": { "atom": "40" } }, + { "Atom": { "atom": "48" } }, + { "Atom": { "atom": "56" } }, + { "Atom": { "atom": "64" } }, + { "Atom": { "atom": "72" } }, + { "Atom": { "atom": "80" } }, + { "Atom": { "atom": "88" } }, + { "Atom": { "atom": "96" } }, + { "Atom": { "atom": "104" } }, + { "Atom": { "atom": "112" } }, + { "Atom": { "atom": "120" } }, + { "Atom": { "atom": "128" } }, + { "Atom": { "atom": "136" } }, + { "Atom": { "atom": "144" } }, + { "Atom": { "atom": "152" } }, + { "Atom": { "atom": "160" } }, + { "Atom": { "atom": "168" } }, + { "Atom": { "atom": "176" } }, + { "Atom": { "atom": "184" } }, + { "Atom": { "atom": "192" } }, + { "Atom": { "atom": "200" } }, + { "Atom": { "atom": "208" } }, + { "Atom": { "atom": "216" } }, + { "Atom": { "atom": "224" } }, + { "Atom": { "atom": "232" } }, + { "Atom": { "atom": "240" } }, + { "Atom": { "atom": "248" } }, + { "Atom": { "atom": "256" } } + ] + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulUncheckedKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.5.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "unchecked" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulUsingKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "using" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulVarKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.6.5" } }, + "value": { "Atom": { "atom": "var" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulViewKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "view" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulVirtualKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Range": { "from": "0.6.0", "till": "0.7.1" } }, + "value": { "Atom": { "atom": "virtual" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulWeeksKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "weeks" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulWeiKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "wei" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulWhileKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "while" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulYearsKeyword", + "identifier": "YulIdentifier", + "definitions": [ + { + "enabled": "Never", + "reserved": { "Till": { "till": "0.7.1" } }, + "value": { "Atom": { "atom": "years" } } + } + ] + } + } + }, + { + "Keyword": { + "item": { + "name": "YulXorKeyword", + "identifier": "YulIdentifier", + "definitions": [{ "value": { "Atom": { "atom": "xor" } } }] + } + } + } + ] + } + ] + } + ], + "built_ins": [ + { + "BuiltInFunction": { + "item": { "name": "addmod", "parameters": ["uint x", "uint y", "uint k"], "return_type": "uint" } + } + }, + { "BuiltInFunction": { "item": { "name": "assert", "parameters": ["bool condition"] } } }, + { + "BuiltInFunction": { + "item": { + "name": "blockhash", + "parameters": ["uint blockNumber"], + "return_type": "bytes32", + "enabled": { "From": { "from": "0.4.22" } } + } + } + }, + { + "BuiltInFunction": { + "item": { + "name": "blobhash", + "parameters": ["uint index"], + "return_type": "bytes32", + "enabled": { "From": { "from": "0.8.24" } } + } + } + }, + { + "BuiltInFunction": { + "item": { + "name": "ecrecover", + "parameters": ["bytes32 hash", "uint8 v", "bytes32 r", "bytes32 s"], + "return_type": "address" + } + } + }, + { + "BuiltInFunction": { + "item": { "name": "gasleft", "return_type": "uint256", "enabled": { "From": { "from": "0.4.22" } } } + } + }, + { + "BuiltInFunction": { "item": { "name": "keccak256", "parameters": ["bytes memory"], "return_type": "bytes32" } } + }, + { + "BuiltInFunction": { + "item": { "name": "log0", "parameters": ["bytes32"], "enabled": { "Till": { "till": "0.8.0" } } } + } + }, + { + "BuiltInFunction": { + "item": { "name": "log1", "parameters": ["bytes32", "bytes32"], "enabled": { "Till": { "till": "0.8.0" } } } + } + }, + { + "BuiltInFunction": { + "item": { + "name": "log2", + "parameters": ["bytes32", "bytes32", "bytes32"], + "enabled": { "Till": { "till": "0.8.0" } } + } + } + }, + { + "BuiltInFunction": { + "item": { + "name": "log3", + "parameters": ["bytes32", "bytes32", "bytes32", "bytes32"], + "enabled": { "Till": { "till": "0.8.0" } } + } + } + }, + { + "BuiltInFunction": { + "item": { + "name": "log4", + "parameters": ["bytes32", "bytes32", "bytes32", "bytes32", "bytes32"], + "enabled": { "Till": { "till": "0.8.0" } } + } + } + }, + { + "BuiltInFunction": { + "item": { "name": "mulmod", "parameters": ["uint x", "uint y", "uint k"], "return_type": "uint" } + } + }, + { "BuiltInFunction": { "item": { "name": "require", "parameters": ["bool condition"] } } }, + { + "BuiltInFunction": { + "item": { + "name": "require", + "parameters": ["bool condition", "string memory message"], + "enabled": { "From": { "from": "0.4.22" } } + } + } + }, + { + "BuiltInFunction": { + "item": { + "name": "require", + "parameters": ["bool condition", "Error error"], + "enabled": { "From": { "from": "0.8.26" } } + } + } + }, + { "BuiltInFunction": { "item": { "name": "revert" } } }, + { + "BuiltInFunction": { + "item": { + "name": "revert", + "parameters": ["string memory reason"], + "enabled": { "From": { "from": "0.4.22" } } + } + } + }, + { + "BuiltInFunction": { "item": { "name": "ripemd160", "parameters": ["bytes memory"], "return_type": "bytes20" } } + }, + { "BuiltInFunction": { "item": { "name": "selfdestruct", "parameters": ["address payable recipient"] } } }, + { "BuiltInFunction": { "item": { "name": "sha256", "parameters": ["bytes memory"], "return_type": "bytes32" } } }, + { + "BuiltInFunction": { + "item": { + "name": "sha3", + "parameters": ["bytes memory"], + "return_type": "bytes32", + "enabled": { "Till": { "till": "0.5.0" } } + } + } + }, + { + "BuiltInFunction": { + "item": { + "name": "suicide", + "parameters": ["address payable recipient"], + "enabled": { "Till": { "till": "0.5.0" } } + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$AbiType", + "functions": [ + { + "name": "decode", + "parameters": ["bytes memory encodedData", "$Type[] encodedTypesTuple"], + "return_type": "$Any[]", + "enabled": { "From": { "from": "0.5.0" } } + }, + { + "name": "encode", + "parameters": ["$Any[] valuesToEncode"], + "return_type": "bytes memory", + "enabled": { "From": { "from": "0.4.22" } } + }, + { + "name": "encodeCall", + "parameters": ["function() functionPointer", "$Any[] functionArgumentsTuple"], + "return_type": "bytes memory", + "enabled": { "From": { "from": "0.8.11" } } + }, + { + "name": "encodePacked", + "parameters": ["$Any[] valuesToEncode"], + "return_type": "bytes memory", + "enabled": { "From": { "from": "0.4.22" } } + }, + { + "name": "encodeWithSelector", + "parameters": ["bytes4 selector", "$Any[] functionArgumentsTuple"], + "return_type": "bytes memory", + "enabled": { "From": { "from": "0.4.22" } } + }, + { + "name": "encodeWithSignature", + "parameters": ["string memory signature", "$Any[] valuesToEncode"], + "return_type": "bytes memory", + "enabled": { "From": { "from": "0.4.22" } } + } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$address", + "fields": [ + { "definition": "uint256 balance" }, + { "definition": "bytes code", "enabled": { "From": { "from": "0.8.0" } } }, + { "definition": "bytes32 codehash", "enabled": { "From": { "from": "0.8.0" } } } + ], + "functions": [ + { + "name": "call", + "parameters": ["bytes memory"], + "return_type": "bool", + "enabled": { "Till": { "till": "0.5.0" } } + }, + { + "name": "call", + "parameters": ["bytes memory"], + "return_type": "bool, bytes memory", + "enabled": { "From": { "from": "0.5.0" } } + }, + { + "name": "callcode", + "parameters": ["bytes memory"], + "return_type": "bool, bytes memory", + "enabled": { "Till": { "till": "0.5.0" } } + }, + { + "name": "delegatecall", + "parameters": ["bytes memory"], + "return_type": "bool", + "enabled": { "Till": { "till": "0.5.0" } } + }, + { + "name": "delegatecall", + "parameters": ["bytes memory"], + "return_type": "bool, bytes memory", + "enabled": { "From": { "from": "0.5.0" } } + }, + { "name": "send", "parameters": ["uint256 amount"], "return_type": "bool" }, + { + "name": "staticcall", + "parameters": ["bytes memory"], + "return_type": "bool, bytes memory", + "enabled": { "From": { "from": "0.5.0" } } + }, + { "name": "transfer", "parameters": ["uint256 amount"] } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$Array", + "fields": [{ "definition": "uint length" }], + "functions": [ + { "name": "push", "return_type": "$ValueType", "enabled": { "From": { "from": "0.6.0" } } }, + { + "name": "push", + "parameters": ["$ValueType element"], + "return_type": "uint", + "enabled": { "Till": { "till": "0.6.0" } } + }, + { "name": "push", "parameters": ["$ValueType element"], "enabled": { "From": { "from": "0.6.0" } } }, + { "name": "pop" } + ] + } + } + }, + { "BuiltInType": { "item": { "name": "$FixedArray", "fields": [{ "definition": "uint length" }] } } }, + { + "BuiltInType": { + "item": { + "name": "$BlockType", + "fields": [ + { "definition": "uint basefee", "enabled": { "From": { "from": "0.8.7" } } }, + { "definition": "uint blobbasefee", "enabled": { "From": { "from": "0.8.24" } } }, + { "definition": "uint chainid", "enabled": { "From": { "from": "0.8.0" } } }, + { "definition": "address payable coinbase" }, + { "definition": "uint difficulty" }, + { "definition": "uint gaslimit" }, + { "definition": "uint number" }, + { "definition": "uint prevrandao", "enabled": { "From": { "from": "0.8.18" } } }, + { "definition": "uint timestamp" } + ], + "functions": [ + { + "name": "blockhash", + "parameters": ["uint"], + "return_type": "bytes32", + "enabled": { "Till": { "till": "0.5.0" } } + } + ] + } + } + }, + { "BuiltInType": { "item": { "name": "$bytes", "fields": [{ "definition": "uint length" }] } } }, + { + "BuiltInType": { + "item": { + "name": "$BytesType", + "functions": [ + { "name": "concat", "parameters": ["bytes[] bytesToConcatenate"], "return_type": "bytes memory" } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$CallOptions", + "fields": [{ "definition": "uint gas" }, { "definition": "uint salt" }, { "definition": "uint value" }], + "enabled": { "From": { "from": "0.6.2" } } + } + } + }, + { + "BuiltInType": { + "item": { + "name": "Error", + "fields": [{ "definition": "string reason" }], + "enabled": { "From": { "from": "0.6.0" } } + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$ErrorType", + "fields": [{ "definition": "bytes4 selector" }], + "enabled": { "From": { "from": "0.8.4" } } + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$Function", + "functions": [ + { + "name": "gas", + "parameters": ["uint amount"], + "return_type": "function()", + "enabled": { "Till": { "till": "0.7.0" } } + }, + { + "name": "value", + "parameters": ["uint amount"], + "return_type": "function()", + "enabled": { "Till": { "till": "0.7.0" } } + } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$ExternalFunction", + "fields": [ + { "definition": "address address", "enabled": { "From": { "from": "0.8.2" } } }, + { "definition": "bytes4 selector", "enabled": { "From": { "from": "0.4.17" } } } + ], + "functions": [ + { + "name": "gas", + "parameters": ["uint amount"], + "return_type": "function()", + "enabled": { "Till": { "till": "0.7.0" } } + }, + { + "name": "value", + "parameters": ["uint amount"], + "return_type": "function()", + "enabled": { "Till": { "till": "0.7.0" } } + } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$MessageType", + "fields": [ + { "definition": "bytes data" }, + { "definition": "uint256 gas", "enabled": { "Till": { "till": "0.5.0" } } }, + { "definition": "address payable sender", "enabled": { "Till": { "till": "0.8.0" } } }, + { "definition": "address sender", "enabled": { "From": { "from": "0.8.0" } } }, + { "definition": "bytes4 sig" }, + { "definition": "uint value" } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "Panic", + "fields": [{ "definition": "uint errorCode" }], + "enabled": { "From": { "from": "0.6.0" } } + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$StringType", + "functions": [ + { "name": "concat", "parameters": ["string[] stringsToConcatenate"], "return_type": "string memory" } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$TransactionType", + "fields": [ + { "definition": "uint gasprice" }, + { "definition": "address payable origin", "enabled": { "Till": { "till": "0.8.0" } } }, + { "definition": "address origin", "enabled": { "From": { "from": "0.8.0" } } } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$ContractTypeType", + "fields": [ + { "definition": "string name" }, + { "definition": "bytes creationCode", "enabled": { "From": { "from": "0.5.3" } } }, + { "definition": "bytes runtimeCode", "enabled": { "From": { "from": "0.5.3" } } }, + { "definition": "bytes4 interfaceId", "enabled": { "From": { "from": "0.6.7" } } } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$InterfaceTypeType", + "fields": [ + { "definition": "string name" }, + { "definition": "bytes4 interfaceId", "enabled": { "From": { "from": "0.6.7" } } } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$IntTypeType", + "fields": [ + { "definition": "int min", "enabled": { "From": { "from": "0.6.8" } } }, + { "definition": "int max", "enabled": { "From": { "from": "0.6.8" } } } + ] + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$UserDefinedValueType", + "functions": [ + { "name": "wrap", "parameters": ["$WrappedType elementaryType"], "return_type": "$UserType" }, + { "name": "unwrap", "parameters": ["$UserType userType"], "return_type": "$WrappedType" } + ], + "enabled": { "From": { "from": "0.8.8" } } + } + } + }, + { + "BuiltInType": { + "item": { + "name": "$YulExternal", + "fields": [{ "definition": "uint slot" }, { "definition": "uint offset" }, { "definition": "uint length" }] + } + } + }, + { "BuiltInVariable": { "item": { "definition": "$Function $placeholder" } } }, + { "BuiltInVariable": { "item": { "definition": "$AbiType abi" } } }, + { "BuiltInVariable": { "item": { "definition": "$BlockType block" } } }, + { "BuiltInVariable": { "item": { "definition": "$BytesType $bytes" } } }, + { "BuiltInVariable": { "item": { "definition": "$MessageType msg" } } }, + { "BuiltInVariable": { "item": { "definition": "uint now", "enabled": { "Till": { "till": "0.7.0" } } } } }, + { "BuiltInVariable": { "item": { "definition": "$StringType $string" } } }, + { "BuiltInVariable": { "item": { "definition": "$TransactionType tx" } } } + ] +} From d248ea0196a6fb40ea6d46bd29aa06656a5a5ee7 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 1 Jan 2025 15:18:44 -0800 Subject: [PATCH 2/4] [cargo] Bump the non-major-dependencies group with 9 updates (#1208) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps the non-major-dependencies group with 9 updates: | Package | From | To | | --- | --- | --- | | [anyhow](https://github.com/dtolnay/anyhow) | `1.0.94` | `1.0.95` | | [console](https://github.com/console-rs/console) | `0.15.8` | `0.15.10` | | [env_logger](https://github.com/rust-cli/env_logger) | `0.11.5` | `0.11.6` | | [quote](https://github.com/dtolnay/quote) | `1.0.37` | `1.0.38` | | [reqwest](https://github.com/seanmonstar/reqwest) | `0.12.9` | `0.12.12` | | [rustdoc-json](https://github.com/cargo-public-api/cargo-public-api) | `0.9.3` | `0.9.4` | | [serde](https://github.com/serde-rs/serde) | `1.0.216` | `1.0.217` | | [serde_json](https://github.com/serde-rs/json) | `1.0.133` | `1.0.134` | | [syn](https://github.com/dtolnay/syn) | `2.0.90` | `2.0.93` | Updates `anyhow` from 1.0.94 to 1.0.95
Release notes

Sourced from anyhow's releases.

1.0.95

Commits
  • 48be1ca Release 1.0.95
  • a03d6d6 Merge pull request #402 from dtolnay/fromboxed
  • 52e4abb Add Error::from_boxed with documentation about bidirectional ?
  • ffecefc Merge pull request #401 from dtolnay/construct
  • 671f700 Add construct_ prefix to name of private construct functions
  • See full diff in compare view

Updates `console` from 0.15.8 to 0.15.10
Release notes

Sourced from console's releases.

0.15.10

What's Changed

0.15.9

What's Changed

Changelog

Sourced from console's changelog.

Changelog

Commits

Updates `env_logger` from 0.11.5 to 0.11.6
Release notes

Sourced from env_logger's releases.

v0.11.6

[0.11.6] - 2024-12-20

Features

  • Opt-in file and line rendering
Changelog

Sourced from env_logger's changelog.

[0.11.6] - 2024-12-20

Features

  • Opt-in file and line rendering
Commits
  • dc1a01a chore: Release
  • 65f81b3 docs: Update changelog
  • 7742599 Merge pull request #345 from EriKWDev/main
  • 59229bc fix: Test result of everything enabled has changed
  • b0d4760 spelling + field names
  • 1bad1f5 feature: ability to display source file path and line number with default for...
  • cc97bf7 chore(deps): Update Rust Stable to v1.83 (#343)
  • 240cd21 style: Make clippy happy
  • da7ff82 chore: Update from _rust template
  • ab1d854 chore(deps): Update Rust crate snapbox to v0.6.20 (#342)
  • Additional commits viewable in compare view

Updates `quote` from 1.0.37 to 1.0.38
Release notes

Sourced from quote's releases.

1.0.38

  • Support interpolating arrays inside of arrays using a repetition (#286)
Commits
  • 0245506 Release 1.0.38
  • d978c51 Merge pull request #286 from dtolnay/array
  • 09d1e42 Implement repetition for arrays
  • 5bba89f Add repetition test with array of array
  • aafba72 Prevent upload-artifact step from causing CI failure
  • c889896 Update not-quotable ui test for ToTokens impl changes
  • 87c247f Resolve some needless_lifetimes clippy lints
  • 31d7a01 Ignore needless_lifetimes clippy lint
  • 6cff24b Upload CI Cargo.lock for reproducing failures
  • See full diff in compare view

Updates `reqwest` from 0.12.9 to 0.12.12
Release notes

Sourced from reqwest's releases.

v0.12.11

What's Changed

Full Changelog: https://github.com/seanmonstar/reqwest/compare/v0.12.10...v0.12.11

v0.12.10

What's Changed

New Contributors

Thanks

Full Changelog: https://github.com/seanmonstar/reqwest/compare/v0.12.9...v0.12.10

Changelog

Sourced from reqwest's changelog.

v0.12.12

  • (wasm) Fix compilation by not compiler tokio/time on WASM.

v0.12.11

  • Fix decompression returning an error when HTTP/2 ends with an empty data frame.

v0.12.10

  • Add ClientBuilder::connector_layer() to allow customizing the connector stack.
  • Add ClientBuilder::http2_max_header_list_size() option.
  • Fix propagating body size hint (content-length) information when wrapping bodies.
  • Fix decompression of chunked bodies so the connections can be reused more often.
Commits

Updates `rustdoc-json` from 0.9.3 to 0.9.4
Changelog

Sourced from rustdoc-json's changelog.

v0.9.4

  • Bump deps. Most notably cargo-manifest from 0.16.0 to 0.17.0.
Commits
  • 5ca99c1 Merge pull request #680 from SUPERCILEX/rustdoc-json-release
  • a98d1df rustdoc-json v0.9.4
  • ec7cb8d Merge pull request #677 from cargo-public-api/dependabot/cargo/home-0.5.11
  • fa6cd6f Merge pull request #678 from cargo-public-api/dependabot/cargo/expect-test-1.5.1
  • 793f0a9 Merge pull request #679 from cargo-public-api/dependabot/cargo/predicates-3.1.3
  • 067a54c build(deps): bump predicates from 3.1.2 to 3.1.3
  • fa200d6 build(deps): bump expect-test from 1.5.0 to 1.5.1
  • 07c170f build(deps): bump home from 0.5.9 to 0.5.11
  • 1d78b9c Merge pull request #676 from cargo-public-api/changelog
  • 3256a9f README.md: Don't reference CHANGELOG.md
  • Additional commits viewable in compare view

Updates `serde` from 1.0.216 to 1.0.217
Release notes

Sourced from serde's releases.

v1.0.217

  • Support serializing externally tagged unit variant inside flattened field (#2786, thanks @​Mingun)
Commits
  • 930401b Release 1.0.217
  • cb6eaea Fix roundtrip inconsistency:
  • b6f339c Resolve repr_packed_without_abi clippy lint in tests
  • 2a5caea Merge pull request #2872 from dtolnay/ehpersonality
  • b9f93f9 Add no-std CI on stable compiler
  • eb5cd47 Drop #[lang = "eh_personality"] from no-std test
  • 8478a3b Merge pull request #2871 from dtolnay/nostdstart
  • dbb9091 Replace #[start] with extern fn main
  • See full diff in compare view

Updates `serde_json` from 1.0.133 to 1.0.134
Release notes

Sourced from serde_json's releases.

v1.0.134

  • Add RawValue associated constants for literal null, true, false (#1221, thanks @​bheylin)
Commits
  • b2a1415 Release 1.0.134
  • 9875785 Tweak wording of NULL/TRUE/FALSE documentation
  • 4aa05b9 Merge pull request #1222 from dtolnay/rawvalueassoc
  • f42c7c7 Move RawValue associated constants into same impl block as public functions
  • 96576ba Merge pull request #1221 from bheylin/add-const-raw-values-for-null-and-bools
  • 4db66fb Add 'static lifetime to const's
  • 9c9aa1f Add literal 'null', 'true' and 'false' consts to RawValue struct.
  • See full diff in compare view

Updates `syn` from 2.0.90 to 2.0.93
Release notes

Sourced from syn's releases.

2.0.93

  • Fix expression parsing edge cases: x as T <<= y (#1804), break as T (#1805), match x { _ if .. => {} } (#1807)
  • Fix expression printing edge cases: || -> T 'a: {} (#1806), if break x {} (#1808, #1810)

2.0.92

  • Fix parenthesization of jumps inside ranges (#1798)

2.0.91

  • Support parsing Vec<Arm> using parse_quote! (#1796, #1797)
Commits
  • 3f2acdc Release 2.0.93
  • 2ecf36a Merge pull request #1810 from dtolnay/confusable
  • 6240d9c Recursive implementation of confusable_with_adjacent_block
  • 39c8d4e Merge pull request #1809 from dtolnay/permutations
  • c770215 Add exhaustive expressions parsing test
  • 672aca9 Exclude slow expressions test from miri
  • 52d1ebb Merge pull request #1808 from dtolnay/ifbreak
  • 7fbb4ae Fix if break x {}
  • 6baa793 Merge pull request #1807 from dtolnay/rangearrow
  • 23f8f3b Fix match x { _ if .. => {} }
  • Additional commits viewable in compare view

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore major version` will close this group update PR and stop Dependabot creating any more for the specific dependency's major version (unless you unignore this specific dependency's major version or upgrade to it yourself) - `@dependabot ignore minor version` will close this group update PR and stop Dependabot creating any more for the specific dependency's minor version (unless you unignore this specific dependency's minor version or upgrade to it yourself) - `@dependabot ignore ` will close this group update PR and stop Dependabot creating any more for the specific dependency (unless you unignore this specific dependency or upgrade to it yourself) - `@dependabot unignore ` will remove all of the ignore conditions of the specified dependency - `@dependabot unignore ` will remove the ignore condition of the specified dependency and ignore conditions
Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- Cargo.lock | 216 ++++++++++++++++++++++++++--------------------------- Cargo.toml | 18 ++--- 2 files changed, 116 insertions(+), 118 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index f0414f1d46..528900d499 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -113,9 +113,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.94" +version = "1.0.95" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1fd03a028ef38ba2276dce7e33fcd6369c158a1bca17946c4b1b701891c1ff7" +checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04" dependencies = [ "backtrace", ] @@ -240,9 +240,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.5.0" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" +checksum = "325918d6fe32f23b19878fe4b34794ae41fc19ddbe53b10571a4874d44ffd39b" [[package]] name = "camino" @@ -261,12 +261,12 @@ checksum = "1582e1c9e755dd6ad6b224dcffb135d199399a4568d454bd89fe515ca8425695" [[package]] name = "cargo-manifest" -version = "0.16.1" +version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "999e8e607fe778257b51e0053903ed97594e56bc7a908c1f77320e9390c3b47b" +checksum = "8b2ce2075c35e4b492b93e3d5dd1dd3670de553f15045595daef8164ed9a3751" dependencies = [ "serde", - "thiserror", + "thiserror 1.0.68", "toml", ] @@ -290,7 +290,7 @@ dependencies = [ "semver", "serde", "serde_json", - "thiserror", + "thiserror 1.0.68", ] [[package]] @@ -380,7 +380,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -414,8 +414,8 @@ dependencies = [ "serde", "strum", "strum_macros", - "syn 2.0.90", - "thiserror", + "syn 2.0.93", + "thiserror 1.0.68", ] [[package]] @@ -425,7 +425,7 @@ dependencies = [ "itertools 0.13.0", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -461,7 +461,7 @@ dependencies = [ "serde", "strum", "strum_macros", - "thiserror", + "thiserror 1.0.68", ] [[package]] @@ -538,15 +538,15 @@ checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7" [[package]] name = "console" -version = "0.15.8" +version = "0.15.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb" +checksum = "ea3c6ecd8059b57859df5c69830340ed3c41d30e3da0c1cbed90a96ac853041b" dependencies = [ "encode_unicode", - "lazy_static", "libc", - "unicode-width 0.1.10", - "windows-sys 0.52.0", + "once_cell", + "unicode-width 0.2.0", + "windows-sys 0.59.0", ] [[package]] @@ -657,7 +657,7 @@ dependencies = [ "ident_case", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -668,7 +668,7 @@ checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178" dependencies = [ "darling_core", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -679,7 +679,7 @@ checksum = "d150dea618e920167e5973d70ae6ece4385b7164e0d799fe7c122dd0a5d912ad" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -706,7 +706,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -717,9 +717,9 @@ checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" [[package]] name = "encode_unicode" -version = "0.3.6" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" [[package]] name = "encoding_rs" @@ -748,7 +748,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -763,9 +763,9 @@ dependencies = [ [[package]] name = "env_logger" -version = "0.11.5" +version = "0.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d" +checksum = "dcaee3d8e3cfc3fd92428d477bc97fc29ec8716d180c0d74c643bb26166660e0" dependencies = [ "anstream", "anstyle", @@ -1051,9 +1051,9 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" [[package]] name = "hyper" -version = "1.3.1" +version = "1.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe575dd17d0862a9a33781c8c4696a55c320909004a67a00fb286ba8b1bc496d" +checksum = "256fb8d4bd6413123cc9d91832d78325c48ff41677595be797d90f42969beae0" dependencies = [ "bytes", "futures-channel", @@ -1104,9 +1104,9 @@ dependencies = [ [[package]] name = "hyper-util" -version = "0.1.3" +version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca38ef113da30126bbff9cd1705f9273e15d45498615d138b0c20279ac7a76aa" +checksum = "df2dcfbe0677734ab2f3ffa7fa7bfd4706bfdc1ef393f2ee30184aed67e631b4" dependencies = [ "bytes", "futures-channel", @@ -1117,7 +1117,6 @@ dependencies = [ "pin-project-lite", "socket2", "tokio", - "tower", "tower-service", "tracing", ] @@ -1144,7 +1143,7 @@ dependencies = [ "quote", "serde", "serde_json", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -1294,7 +1293,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -1550,7 +1549,7 @@ dependencies = [ "once_cell", "semver", "stack-graphs", - "thiserror", + "thiserror 1.0.68", ] [[package]] @@ -1559,7 +1558,7 @@ version = "0.18.3" dependencies = [ "nom", "serde", - "thiserror", + "thiserror 1.0.68", ] [[package]] @@ -1577,7 +1576,7 @@ dependencies = [ "string-interner", "strum", "strum_macros", - "thiserror", + "thiserror 1.0.68", ] [[package]] @@ -1703,7 +1702,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -1751,7 +1750,7 @@ version = "2.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1acb4a4365a13f749a93f1a094a7805e5cfa0955373a9de860d962eaa3a5fe5a" dependencies = [ - "thiserror", + "thiserror 1.0.68", "ucd-trie", ] @@ -1775,7 +1774,7 @@ dependencies = [ "pest_meta", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -1827,26 +1826,6 @@ dependencies = [ "siphasher", ] -[[package]] -name = "pin-project" -version = "1.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3" -dependencies = [ - "pin-project-internal", -] - -[[package]] -name = "pin-project-internal" -version = "1.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.90", -] - [[package]] name = "pin-project-lite" version = "0.2.13" @@ -1890,7 +1869,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e" dependencies = [ "proc-macro2", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -1936,14 +1915,14 @@ dependencies = [ "rustdoc-types", "serde", "serde_json", - "thiserror", + "thiserror 1.0.68", ] [[package]] name = "quote" -version = "1.0.37" +version = "1.0.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc" dependencies = [ "proc-macro2", ] @@ -2041,9 +2020,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" [[package]] name = "reqwest" -version = "0.12.9" +version = "0.12.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a77c62af46e79de0a562e1a9849205ffcb7fc1238876e9bd743357570e04046f" +checksum = "43e734407157c3c2034e0258f5e4473ddb361b1e85f95a66690d67264d7cd1da" dependencies = [ "base64", "bytes", @@ -2075,6 +2054,7 @@ dependencies = [ "system-configuration", "tokio", "tokio-native-tls", + "tower", "tower-service", "url", "wasm-bindgen", @@ -2106,14 +2086,14 @@ checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76" [[package]] name = "rustdoc-json" -version = "0.9.3" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f95a83030cb4956fb60f3dda850a94c4ca31324b356b68d2ae8838d1d0e06b1d" +checksum = "b9cba50605762dcbc2e103a3a8b195c83b6978aca443c7dd6699ed2971c213e5" dependencies = [ "cargo-manifest", "cargo_metadata", "serde", - "thiserror", + "thiserror 2.0.9", "toml", "tracing", ] @@ -2250,29 +2230,29 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.216" +version = "1.0.217" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e" +checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.216" +version = "1.0.217" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e" +checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] name = "serde_json" -version = "1.0.133" +version = "1.0.134" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377" +checksum = "d00f4175c42ee48b15416f6193a959ba3a0d67fc699a0db9ad12df9f83991c7d" dependencies = [ "indexmap", "itoa", @@ -2363,7 +2343,7 @@ dependencies = [ "solidity_language", "strum", "strum_macros", - "thiserror", + "thiserror 1.0.68", ] [[package]] @@ -2391,7 +2371,7 @@ dependencies = [ "strum", "strum_macros", "testlang_language", - "thiserror", + "thiserror 1.0.68", ] [[package]] @@ -2578,7 +2558,7 @@ dependencies = [ "libc", "lsp-positions", "smallvec", - "thiserror", + "thiserror 1.0.68", ] [[package]] @@ -2614,7 +2594,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -2636,9 +2616,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.90" +version = "2.0.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31" +checksum = "9c786062daee0d6db1132800e623df74274a0a87322d8e183338e01b3d98d058" dependencies = [ "proc-macro2", "quote", @@ -2662,7 +2642,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -2801,7 +2781,16 @@ version = "1.0.68" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "02dd99dc800bbb97186339685293e1cc5d9df1f8fae2d0aecd9ff1c77efea892" dependencies = [ - "thiserror-impl", + "thiserror-impl 1.0.68", +] + +[[package]] +name = "thiserror" +version = "2.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f072643fd0190df67a8bab670c20ef5d8737177d6ac6b2e9a236cb096206b2cc" +dependencies = [ + "thiserror-impl 2.0.9", ] [[package]] @@ -2812,7 +2801,18 @@ checksum = "a7c61ec9a6f64d2793d8a45faba21efbe3ced62a886d44c36a009b2b519b4c7e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b50fa271071aae2e6ee85f842e2e28ba8cd2c5fb67f11fcb1fd70b276f9e7d4" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.93", ] [[package]] @@ -2912,39 +2912,37 @@ dependencies = [ [[package]] name = "tower" -version = "0.4.13" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c" +checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9" dependencies = [ "futures-core", "futures-util", - "pin-project", "pin-project-lite", + "sync_wrapper", "tokio", "tower-layer", "tower-service", - "tracing", ] [[package]] name = "tower-layer" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0" +checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e" [[package]] name = "tower-service" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" +checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" [[package]] name = "tracing" -version = "0.1.40" +version = "0.1.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" +checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0" dependencies = [ - "log", "pin-project-lite", "tracing-attributes", "tracing-core", @@ -2952,20 +2950,20 @@ dependencies = [ [[package]] name = "tracing-attributes" -version = "0.1.27" +version = "0.1.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" +checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] name = "tracing-core" -version = "0.1.32" +version = "0.1.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" +checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c" dependencies = [ "once_cell", ] @@ -3211,7 +3209,7 @@ dependencies = [ "once_cell", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", "wasm-bindgen-shared", ] @@ -3245,7 +3243,7 @@ checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -3582,7 +3580,7 @@ dependencies = [ "heck", "indexmap", "prettyplease", - "syn 2.0.90", + "syn 2.0.93", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -3598,7 +3596,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", "wit-bindgen-core", "wit-bindgen-rust", ] @@ -3687,7 +3685,7 @@ checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", "synstructure", ] @@ -3708,7 +3706,7 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] [[package]] @@ -3728,7 +3726,7 @@ checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", "synstructure", ] @@ -3757,5 +3755,5 @@ checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.93", ] diff --git a/Cargo.toml b/Cargo.toml index 9de5256933..21308200f8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -89,7 +89,7 @@ testlang_npm_package = { path = "crates/testlang/outputs/npm/package", version = # # External # -anyhow = { version = "1.0.94", features = ["backtrace", "std"] } +anyhow = { version = "1.0.95", features = ["backtrace", "std"] } ariadne = { version = "0.2.0" } # Currently 'bencher' backend API is under development/unstable. # They recommend always running with the latest CLI version from 'main' until it is stabilized. @@ -101,9 +101,9 @@ cargo-xwin = { version = "0.14.2" } cargo-zigbuild = { version = "0.18.3" } clap = { version = "4.5.13", features = ["derive", "wrap_help"] } clap_complete = { version = "4.5.13" } -console = { version = "0.15.8" } +console = { version = "0.15.10" } derive-new = { version = "0.6.0" } -env_logger = { version = "0.11.5" } +env_logger = { version = "0.11.6" } iai-callgrind = { version = "0.12.3" } iai-callgrind-runner = { version = "0.12.3" } ignore = { version = "0.4.23" } @@ -120,14 +120,14 @@ once_cell = { version = "1.20.2" } paste = { version = "1.0.15" } proc-macro2 = { version = "1.0.92" } public-api = { version = "0.37.0" } -quote = { version = "1.0.37" } +quote = { version = "1.0.38" } rayon = { version = "1.10.0" } regex = { version = "1.11.1" } -reqwest = { version = "0.12.9", features = ["blocking"] } -rustdoc-json = { version = "0.9.3" } +reqwest = { version = "0.12.12", features = ["blocking"] } +rustdoc-json = { version = "0.9.4" } semver = { version = "1.0.24", features = ["serde"] } -serde = { version = "1.0.216", features = ["derive", "rc"] } -serde_json = { version = "1.0.133", features = ["preserve_order"] } +serde = { version = "1.0.217", features = ["derive", "rc"] } +serde_json = { version = "1.0.134", features = ["preserve_order"] } similar-asserts = { version = "1.6.0" } smallvec = { version = "1.7.0", features = ["union"] } stack-graphs = { version = "0.13.0" } @@ -138,7 +138,7 @@ string-interner = { version = "0.17.0", features = [ ] } strum = { version = "0.26.3" } strum_macros = { version = "0.26.4" } -syn = { version = "2.0.90", features = [ +syn = { version = "2.0.93", features = [ "fold", "full", "extra-traits", From 35d89d636665cf32e5f865ccddd0727eaae0c5bc Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 1 Jan 2025 23:19:38 +0000 Subject: [PATCH 3/4] [npm] Bump the non-major-dependencies group with 4 updates (#1209) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps the non-major-dependencies group with 4 updates: [@changesets/cli](https://github.com/changesets/changesets), [@types/node](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/node), [cspell](https://github.com/streetsidesoftware/cspell/tree/HEAD/packages/cspell) and [prettier](https://github.com/prettier/prettier). Updates `@changesets/cli` from 2.27.10 to 2.27.11
Release notes

Sourced from @​changesets/cli's releases.

@​changesets/cli@​2.27.11

Patch Changes

  • Updated dependencies [f0270f6]:
    • @​changesets/config@​3.0.5
    • @​changesets/apply-release-plan@​7.0.7
    • @​changesets/get-release-plan@​4.0.6
Commits

Updates `@types/node` from 22.10.0 to 22.10.3
Commits

Updates `cspell` from 8.16.0 to 8.17.1
Release notes

Sourced from cspell's releases.

v8.17.1

Changes

Fixes

fix: Make sure empty string is not checked. (#6680)

For some strange reason, the Hungarian dictionary ends up with a forbid on empty string. This would happen when matching against "..

v8.17.0

Changes

Features

feat: Support Windows UNC files. (#6671)

feat: Do not spell check random strings (#6615)

Added two new configuration options:

  • ignoreRandomStrings - (default true) tell the spell checker to ignore strings of random characters.
  • minRandomLength - (default 40) the minimum length of a string of characters before checking if it is random.

fixes #6573

Fixes

... (truncated)

Changelog

Sourced from cspell's changelog.

8.17.1 (2024-12-16)

8.17.0 (2024-12-15)

8.16.1 (2024-11-26)

Commits

Updates `prettier` from 3.4.0 to 3.4.2
Release notes

Sourced from prettier's releases.

3.4.2

🔗 Changelog

3.4.1

🔗 Changelog

Changelog

Sourced from prettier's changelog.

3.4.2

diff

Treat U+30A0 & U+30FB in Katakana Block as CJK (#16796 by @​tats-u)

Prettier doesn't treat U+30A0 & U+30FB as Japanese. U+30FB is commonly used in Japanese to represent the delimitation of first and last names of non-Japanese people or “and”. The following “C言語・C++・Go・Rust” means “C language & C++ & Go & Rust” in Japanese.

<!-- Input (--prose-wrap=never) -->

C言

語

・

C++

・

Go

・

Rust


<!-- Prettier 3.4.1 -->

C言語・ C++ ・ Go ・ Rust


<!-- Prettier 3.4.2 -->

C言語・C++・Go・Rust

U+30A0 can be used as the replacement of the - in non-Japanese names (e.g. “Saint-Saëns” (Charles Camille Saint-Saëns) can be represented as “サン゠サーンス” in Japanese), but substituted by ASCII hyphen (U+002D) or U+FF1D (full width hyphen) in many cases (e.g. “サン=サーンス” or “サン＝サーンス”).

Fix comments print on class methods with decorators (#16891 by @​fisker)

// Input
class A {
  @decorator
  /**
   * The method description
   *
  */
  async method(foo: Foo, bar: Bar) {
    console.log(foo);
  }
}

// Prettier 3.4.1

class A {

@​decorator

async /**

</tr></table>

... (truncated)

Commits

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore major version` will close this group update PR and stop Dependabot creating any more for the specific dependency's major version (unless you unignore this specific dependency's major version or upgrade to it yourself) - `@dependabot ignore minor version` will close this group update PR and stop Dependabot creating any more for the specific dependency's minor version (unless you unignore this specific dependency's minor version or upgrade to it yourself) - `@dependabot ignore ` will close this group update PR and stop Dependabot creating any more for the specific dependency (unless you unignore this specific dependency or upgrade to it yourself) - `@dependabot unignore ` will remove all of the ignore conditions of the specified dependency - `@dependabot unignore ` will remove the ignore condition of the specified dependency and ignore conditions
Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- crates/infra/cli/package.json | 8 +- package-lock.json | 884 ++++++++++++++-------------------- 2 files changed, 371 insertions(+), 521 deletions(-) diff --git a/crates/infra/cli/package.json b/crates/infra/cli/package.json index bc80805dc9..b37d6813c3 100644 --- a/crates/infra/cli/package.json +++ b/crates/infra/cli/package.json @@ -4,13 +4,13 @@ "devDependencies": { "@actions/github": "6.0.0", "@changesets/changelog-github": "0.5.0", - "@changesets/cli": "2.27.10", - "@types/node": "22.10.0", - "cspell": "8.16.0", + "@changesets/cli": "2.27.11", + "@types/node": "22.10.3", + "cspell": "8.17.1", "markdown-link-check": "3.12.2", "markdownlint-cli": "0.43.0", "prettier-plugin-sh": "0.14.0", - "prettier": "3.4.0", + "prettier": "3.4.2", "remark-parse": "11.0.0", "remark-stringify": "11.0.0", "typescript": "5.7.2", diff --git a/package-lock.json b/package-lock.json index d3b6c9284c..b49117c1ea 100644 --- a/package-lock.json +++ b/package-lock.json @@ -35,12 +35,12 @@ "devDependencies": { "@actions/github": "6.0.0", "@changesets/changelog-github": "0.5.0", - "@changesets/cli": "2.27.10", - "@types/node": "22.10.0", - "cspell": "8.16.0", + "@changesets/cli": "2.27.11", + "@types/node": "22.10.3", + "cspell": "8.17.1", "markdown-link-check": "3.12.2", "markdownlint-cli": "0.43.0", - "prettier": "3.4.0", + "prettier": "3.4.2", "prettier-plugin-sh": "0.14.0", "remark-parse": "11.0.0", "remark-stringify": "11.0.0", @@ -577,7 +577,6 @@ "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.0.tgz", "integrity": "sha512-FDSOghenHTiToteC/QRlv2q3DhPZ/oOXTBoirfWNx1Cx3TMVcGWQtMMmQcSvb/JjpNeGzx8Pq/b4fKEJuWm1sw==", "dev": true, - "license": "MIT", "dependencies": { "regenerator-runtime": "^0.14.0" }, @@ -646,13 +645,12 @@ "integrity": "sha512-h1qLL0TN5KXk/zagY2BtbZuDX6xYjz4Br9RZXEa0ID4UpiPc0agUMhTdz9r89G4vX5SU/tqBg1A6UNv2+DJ5pg==" }, "node_modules/@changesets/apply-release-plan": { - "version": "7.0.6", - "resolved": "https://registry.npmjs.org/@changesets/apply-release-plan/-/apply-release-plan-7.0.6.tgz", - "integrity": "sha512-TKhVLtiwtQOgMAC0fCJfmv93faiViKSDqr8oMEqrnNs99gtSC1sZh/aEMS9a+dseU1ESZRCK+ofLgGY7o0fw/Q==", + "version": "7.0.7", + "resolved": "https://registry.npmjs.org/@changesets/apply-release-plan/-/apply-release-plan-7.0.7.tgz", + "integrity": "sha512-qnPOcmmmnD0MfMg9DjU1/onORFyRpDXkMMl2IJg9mECY6RnxL3wN0TCCc92b2sXt1jt8DgjAUUsZYGUGTdYIXA==", "dev": true, - "license": "MIT", "dependencies": { - "@changesets/config": "^3.0.4", + "@changesets/config": "^3.0.5", "@changesets/get-version-range-type": "^0.4.0", "@changesets/git": "^3.0.2", "@changesets/should-skip-package": "^0.1.1", @@ -672,7 +670,6 @@ "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz", "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==", "dev": true, - "license": "MIT", "bin": { "prettier": "bin-prettier.js" }, @@ -688,7 +685,6 @@ "resolved": "https://registry.npmjs.org/@changesets/assemble-release-plan/-/assemble-release-plan-6.0.5.tgz", "integrity": "sha512-IgvBWLNKZd6k4t72MBTBK3nkygi0j3t3zdC1zrfusYo0KpdsvnDjrMM9vPnTCLCMlfNs55jRL4gIMybxa64FCQ==", "dev": true, - "license": "MIT", "dependencies": { "@changesets/errors": "^0.2.0", "@changesets/get-dependents-graph": "^2.1.2", @@ -719,19 +715,18 @@ } }, "node_modules/@changesets/cli": { - "version": "2.27.10", - "resolved": "https://registry.npmjs.org/@changesets/cli/-/cli-2.27.10.tgz", - "integrity": "sha512-PfeXjvs9OfQJV8QSFFHjwHX3QnUL9elPEQ47SgkiwzLgtKGyuikWjrdM+lO9MXzOE22FO9jEGkcs4b+B6D6X0Q==", + "version": "2.27.11", + "resolved": "https://registry.npmjs.org/@changesets/cli/-/cli-2.27.11.tgz", + "integrity": "sha512-1QislpE+nvJgSZZo9+Lj3Lno5pKBgN46dAV8IVxKJy9wX8AOrs9nn5pYVZuDpoxWJJCALmbfOsHkyxujgetQSg==", "dev": true, - "license": "MIT", "dependencies": { - "@changesets/apply-release-plan": "^7.0.6", + "@changesets/apply-release-plan": "^7.0.7", "@changesets/assemble-release-plan": "^6.0.5", "@changesets/changelog-git": "^0.2.0", - "@changesets/config": "^3.0.4", + "@changesets/config": "^3.0.5", "@changesets/errors": "^0.2.0", "@changesets/get-dependents-graph": "^2.1.2", - "@changesets/get-release-plan": "^4.0.5", + "@changesets/get-release-plan": "^4.0.6", "@changesets/git": "^3.0.2", "@changesets/logger": "^0.1.1", "@changesets/pre": "^2.0.1", @@ -742,7 +737,7 @@ "@manypkg/get-packages": "^1.1.3", "ansi-colors": "^4.1.3", "ci-info": "^3.7.0", - "enquirer": "^2.3.0", + "enquirer": "^2.4.1", "external-editor": "^3.1.0", "fs-extra": "^7.0.1", "mri": "^1.2.0", @@ -759,11 +754,10 @@ } }, "node_modules/@changesets/config": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/@changesets/config/-/config-3.0.4.tgz", - "integrity": "sha512-+DiIwtEBpvvv1z30f8bbOsUQGuccnZl9KRKMM/LxUHuDu5oEjmN+bJQ1RIBKNJjfYMQn8RZzoPiX0UgPaLQyXw==", + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/@changesets/config/-/config-3.0.5.tgz", + "integrity": "sha512-QyXLSSd10GquX7hY0Mt4yQFMEeqnO5z/XLpbIr4PAkNNoQNKwDyiSrx4yd749WddusH1v3OSiA0NRAYmH/APpQ==", "dev": true, - "license": "MIT", "dependencies": { "@changesets/errors": "^0.2.0", "@changesets/get-dependents-graph": "^2.1.2", @@ -779,7 +773,6 @@ "resolved": "https://registry.npmjs.org/@changesets/errors/-/errors-0.2.0.tgz", "integrity": "sha512-6BLOQUscTpZeGljvyQXlWOItQyU71kCdGz7Pi8H8zdw6BI0g3m43iL4xKUVPWtG+qrrL9DTjpdn8eYuCQSRpow==", "dev": true, - "license": "MIT", "dependencies": { "extendable-error": "^0.1.5" } @@ -789,7 +782,6 @@ "resolved": "https://registry.npmjs.org/@changesets/get-dependents-graph/-/get-dependents-graph-2.1.2.tgz", "integrity": "sha512-sgcHRkiBY9i4zWYBwlVyAjEM9sAzs4wYVwJUdnbDLnVG3QwAaia1Mk5P8M7kraTOZN+vBET7n8KyB0YXCbFRLQ==", "dev": true, - "license": "MIT", "dependencies": { "@changesets/types": "^6.0.0", "@manypkg/get-packages": "^1.1.3", @@ -808,14 +800,13 @@ } }, "node_modules/@changesets/get-release-plan": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/@changesets/get-release-plan/-/get-release-plan-4.0.5.tgz", - "integrity": "sha512-E6wW7JoSMcctdVakut0UB76FrrN3KIeJSXvB+DHMFo99CnC3ZVnNYDCVNClMlqAhYGmLmAj77QfApaI3ca4Fkw==", + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/@changesets/get-release-plan/-/get-release-plan-4.0.6.tgz", + "integrity": "sha512-FHRwBkY7Eili04Y5YMOZb0ezQzKikTka4wL753vfUA5COSebt7KThqiuCN9BewE4/qFGgF/5t3AuzXx1/UAY4w==", "dev": true, - "license": "MIT", "dependencies": { "@changesets/assemble-release-plan": "^6.0.5", - "@changesets/config": "^3.0.4", + "@changesets/config": "^3.0.5", "@changesets/pre": "^2.0.1", "@changesets/read": "^0.6.2", "@changesets/types": "^6.0.0", @@ -826,15 +817,13 @@ "version": "0.4.0", "resolved": "https://registry.npmjs.org/@changesets/get-version-range-type/-/get-version-range-type-0.4.0.tgz", "integrity": "sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/@changesets/git": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/@changesets/git/-/git-3.0.2.tgz", "integrity": "sha512-r1/Kju9Y8OxRRdvna+nxpQIsMsRQn9dhhAZt94FLDeu0Hij2hnOozW8iqnHBgvu+KdnJppCveQwK4odwfw/aWQ==", "dev": true, - "license": "MIT", "dependencies": { "@changesets/errors": "^0.2.0", "@manypkg/get-packages": "^1.1.3", @@ -848,7 +837,6 @@ "resolved": "https://registry.npmjs.org/@changesets/logger/-/logger-0.1.1.tgz", "integrity": "sha512-OQtR36ZlnuTxKqoW4Sv6x5YIhOmClRd5pWsjZsddYxpWs517R0HkyiefQPIytCVh4ZcC5x9XaG8KTdd5iRQUfg==", "dev": true, - "license": "MIT", "dependencies": { "picocolors": "^1.1.0" } @@ -858,7 +846,6 @@ "resolved": "https://registry.npmjs.org/@changesets/parse/-/parse-0.4.0.tgz", "integrity": "sha512-TS/9KG2CdGXS27S+QxbZXgr8uPsP4yNJYb4BC2/NeFUj80Rni3TeD2qwWmabymxmrLo7JEsytXH1FbpKTbvivw==", "dev": true, - "license": "MIT", "dependencies": { "@changesets/types": "^6.0.0", "js-yaml": "^3.13.1" @@ -869,7 +856,6 @@ "resolved": "https://registry.npmjs.org/@changesets/pre/-/pre-2.0.1.tgz", "integrity": "sha512-vvBJ/If4jKM4tPz9JdY2kGOgWmCowUYOi5Ycv8dyLnEE8FgpYYUo1mgJZxcdtGGP3aG8rAQulGLyyXGSLkIMTQ==", "dev": true, - "license": "MIT", "dependencies": { "@changesets/errors": "^0.2.0", "@changesets/types": "^6.0.0", @@ -882,7 +868,6 @@ "resolved": "https://registry.npmjs.org/@changesets/read/-/read-0.6.2.tgz", "integrity": "sha512-wjfQpJvryY3zD61p8jR87mJdyx2FIhEcdXhKUqkja87toMrP/3jtg/Yg29upN+N4Ckf525/uvV7a4tzBlpk6gg==", "dev": true, - "license": "MIT", "dependencies": { "@changesets/git": "^3.0.2", "@changesets/logger": "^0.1.1", @@ -898,7 +883,6 @@ "resolved": "https://registry.npmjs.org/@changesets/should-skip-package/-/should-skip-package-0.1.1.tgz", "integrity": "sha512-H9LjLbF6mMHLtJIc/eHR9Na+MifJ3VxtgP/Y+XLn4BF7tDTEN1HNYtH6QMcjP1uxp9sjaFYmW8xqloaCi/ckTg==", "dev": true, - "license": "MIT", "dependencies": { "@changesets/types": "^6.0.0", "@manypkg/get-packages": "^1.1.3" @@ -938,18 +922,17 @@ } }, "node_modules/@cspell/cspell-bundled-dicts": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/cspell-bundled-dicts/-/cspell-bundled-dicts-8.16.0.tgz", - "integrity": "sha512-R0Eqq5kTZnmZ0elih5uY3TWjMqqAeMl7ciU7maUs+m1FNjCEdJXtJ9wrQxNgjmXi0tX8cvahZRO3O558tEz/KA==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/cspell-bundled-dicts/-/cspell-bundled-dicts-8.17.1.tgz", + "integrity": "sha512-HmkXS5uX4bk/XxsRS4Q+zRvhgRa81ddGiR2/Xfag9MIi5L5UnEJ4g21EpmIlXkMxYrTu2fp69SZFss5NfcFF9Q==", "dev": true, - "license": "MIT", "dependencies": { "@cspell/dict-ada": "^4.0.5", "@cspell/dict-al": "^1.0.3", "@cspell/dict-aws": "^4.0.7", "@cspell/dict-bash": "^4.1.8", - "@cspell/dict-companies": "^3.1.7", - "@cspell/dict-cpp": "^6.0.1", + "@cspell/dict-companies": "^3.1.8", + "@cspell/dict-cpp": "^6.0.2", "@cspell/dict-cryptocurrencies": "^5.0.3", "@cspell/dict-csharp": "^4.0.5", "@cspell/dict-css": "^4.0.16", @@ -958,17 +941,17 @@ "@cspell/dict-docker": "^1.1.11", "@cspell/dict-dotnet": "^5.0.8", "@cspell/dict-elixir": "^4.0.6", - "@cspell/dict-en_us": "^4.3.26", + "@cspell/dict-en_us": "^4.3.28", "@cspell/dict-en-common-misspellings": "^2.0.7", "@cspell/dict-en-gb": "1.1.33", - "@cspell/dict-filetypes": "^3.0.8", + "@cspell/dict-filetypes": "^3.0.9", "@cspell/dict-flutter": "^1.0.3", "@cspell/dict-fonts": "^4.0.3", "@cspell/dict-fsharp": "^1.0.4", "@cspell/dict-fullstack": "^3.2.3", - "@cspell/dict-gaming-terms": "^1.0.8", + "@cspell/dict-gaming-terms": "^1.0.9", "@cspell/dict-git": "^3.0.3", - "@cspell/dict-golang": "^6.0.16", + "@cspell/dict-golang": "^6.0.17", "@cspell/dict-google": "^1.0.4", "@cspell/dict-haskell": "^4.0.4", "@cspell/dict-html": "^4.0.10", @@ -983,16 +966,16 @@ "@cspell/dict-markdown": "^2.0.7", "@cspell/dict-monkeyc": "^1.0.9", "@cspell/dict-node": "^5.0.5", - "@cspell/dict-npm": "^5.1.11", + "@cspell/dict-npm": "^5.1.17", "@cspell/dict-php": "^4.0.13", "@cspell/dict-powershell": "^5.0.13", "@cspell/dict-public-licenses": "^2.0.11", - "@cspell/dict-python": "^4.2.12", + "@cspell/dict-python": "^4.2.13", "@cspell/dict-r": "^2.0.4", "@cspell/dict-ruby": "^5.0.7", - "@cspell/dict-rust": "^4.0.9", + "@cspell/dict-rust": "^4.0.10", "@cspell/dict-scala": "^5.0.6", - "@cspell/dict-software-terms": "^4.1.13", + "@cspell/dict-software-terms": "^4.1.19", "@cspell/dict-sql": "^2.1.8", "@cspell/dict-svelte": "^1.0.5", "@cspell/dict-swift": "^2.0.4", @@ -1005,34 +988,31 @@ } }, "node_modules/@cspell/cspell-json-reporter": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/cspell-json-reporter/-/cspell-json-reporter-8.16.0.tgz", - "integrity": "sha512-KLjPK94gA3JNuWy70LeenJ6EL3SFk2ejERKYJ6SVV/cVOKIvVd2qe42yX3/A/DkF2xzuZ2LD4z0sfoqQL1BaqA==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/cspell-json-reporter/-/cspell-json-reporter-8.17.1.tgz", + "integrity": "sha512-EV9Xkh42Xw3aORvDZfxusICX91DDbqQpYdGKBdPGuhgxWOUYYZKpLXsHCmDkhruMPo2m5gDh++/OqjLRPZofKQ==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/cspell-types": "8.16.0" + "@cspell/cspell-types": "8.17.1" }, "engines": { "node": ">=18" } }, "node_modules/@cspell/cspell-pipe": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/cspell-pipe/-/cspell-pipe-8.16.0.tgz", - "integrity": "sha512-WoCgrv/mrtwCY4lhc6vEcqN3AQ7lT6K0NW5ShoSo116U2tRaW0unApIYH4Va8u7T9g3wyspFEceQRR1xD9qb9w==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/cspell-pipe/-/cspell-pipe-8.17.1.tgz", + "integrity": "sha512-uhC99Ox+OH3COSgShv4fpVHiotR70dNvAOSkzRvKVRzV6IGyFnxHjmyVVPEV0dsqzVLxltwYTqFhwI+UOwm45A==", "dev": true, - "license": "MIT", "engines": { "node": ">=18" } }, "node_modules/@cspell/cspell-resolver": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/cspell-resolver/-/cspell-resolver-8.16.0.tgz", - "integrity": "sha512-b+99bph43ptkXlQHgPXSkN/jK6LQHy2zL1Fm9up7+x6Yr64bxAzWzoeqJAPtnrPvFuOrFN0jZasZzKBw8CvrrQ==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/cspell-resolver/-/cspell-resolver-8.17.1.tgz", + "integrity": "sha512-XEK2ymTdQNgsV3ny60VkKzWskbICl4zNXh/DbxsoRXHqIRg43MXFpTNkEJ7j873EqdX7BU4opQQ+5D4stWWuhQ==", "dev": true, - "license": "MIT", "dependencies": { "global-directory": "^4.0.1" }, @@ -1041,433 +1021,375 @@ } }, "node_modules/@cspell/cspell-service-bus": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/cspell-service-bus/-/cspell-service-bus-8.16.0.tgz", - "integrity": "sha512-+fn763JKA4EYCOv+1VShFq015UMEBAFRDr+rlCnesgLE0fv9TSFVLsjOfh9/g6GuGQLCRLUqKztwwuueeErstQ==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/cspell-service-bus/-/cspell-service-bus-8.17.1.tgz", + "integrity": "sha512-2sFWQtMEWZ4tdz7bw0bAx4NaV1t0ynGfjpuKWdQppsJFKNb+ZPZZ6Ah1dC13AdRRMZaG194kDRFwzNvRaCgWkQ==", "dev": true, - "license": "MIT", "engines": { "node": ">=18" } }, "node_modules/@cspell/cspell-types": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/cspell-types/-/cspell-types-8.16.0.tgz", - "integrity": "sha512-bGrIK7p4NVsK+QX/CYWmjax+FkzfSIZaIaoiBESGV5gmwgXDVRMJ3IP6tQVAmTtckOYHCmtT5CZgI8zXWr8dHQ==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/cspell-types/-/cspell-types-8.17.1.tgz", + "integrity": "sha512-NJbov7Jp57fh8addoxesjb8atg/APQfssCH5Q9uZuHBN06wEJDgs7fhfE48bU+RBViC9gltblsYZzZZQKzHYKg==", "dev": true, - "license": "MIT", "engines": { "node": ">=18" } }, "node_modules/@cspell/dict-ada": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/@cspell/dict-ada/-/dict-ada-4.0.5.tgz", - "integrity": "sha512-6/RtZ/a+lhFVmrx/B7bfP7rzC4yjEYe8o74EybXcvu4Oue6J4Ey2WSYj96iuodloj1LWrkNCQyX5h4Pmcj0Iag==", - "dev": true, - "license": "MIT" + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/@cspell/dict-ada/-/dict-ada-4.0.6.tgz", + "integrity": "sha512-1DpA3LeidQS5Wec5ZnrIRtuv/ijUcfcUq8G5hj/3QZT4vTTRXtIaQnfsq7t3XYsRlisYHkVmm2CgsJ/8hKChLw==", + "dev": true }, "node_modules/@cspell/dict-al": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/@cspell/dict-al/-/dict-al-1.0.3.tgz", - "integrity": "sha512-V1HClwlfU/qwSq2Kt+MkqRAsonNu3mxjSCDyGRecdLGIHmh7yeEeaxqRiO/VZ4KP+eVSiSIlbwrb5YNFfxYZbw==", - "dev": true, - "license": "MIT" + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@cspell/dict-al/-/dict-al-1.0.4.tgz", + "integrity": "sha512-W4ppuwhZN6A1genmj9Q4NC8UKy7TrRb7UjvMsuPDen+V8anePTys9a0DpKp3z0S6nlrcZgqYNe9Hw/9k76mkAQ==", + "dev": true }, "node_modules/@cspell/dict-aws": { - "version": "4.0.7", - "resolved": "https://registry.npmjs.org/@cspell/dict-aws/-/dict-aws-4.0.7.tgz", - "integrity": "sha512-PoaPpa2NXtSkhGIMIKhsJUXB6UbtTt6Ao3x9JdU9kn7fRZkwD4RjHDGqulucIOz7KeEX/dNRafap6oK9xHe4RA==", - "dev": true, - "license": "MIT" + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/@cspell/dict-aws/-/dict-aws-4.0.8.tgz", + "integrity": "sha512-9gYdKw34dorYbwh+ycUDNQQHfkUTBRKQNriSUXB0L/SA/k1bbFuD7qQxUmSmmH+Q0AjDCJ41OntF7l/Ok1H3ig==", + "dev": true }, "node_modules/@cspell/dict-bash": { - "version": "4.1.8", - "resolved": "https://registry.npmjs.org/@cspell/dict-bash/-/dict-bash-4.1.8.tgz", - "integrity": "sha512-I2CM2pTNthQwW069lKcrVxchJGMVQBzru2ygsHCwgidXRnJL/NTjAPOFTxN58Jc1bf7THWghfEDyKX/oyfc0yg==", - "dev": true, - "license": "MIT" + "version": "4.1.9", + "resolved": "https://registry.npmjs.org/@cspell/dict-bash/-/dict-bash-4.1.9.tgz", + "integrity": "sha512-Gl7tE1dFgtZHUZTpzAA4/HyKE9QXJ1dyDrru98J4LdhTPaoyXW+b8hfr4y7n21zzEqE2zAW4fi3o85IY28uPTQ==", + "dev": true }, "node_modules/@cspell/dict-companies": { - "version": "3.1.7", - "resolved": "https://registry.npmjs.org/@cspell/dict-companies/-/dict-companies-3.1.7.tgz", - "integrity": "sha512-ncVs/efuAkP1/tLDhWbXukBjgZ5xOUfe03neHMWsE8zvXXc5+Lw6TX5jaJXZLOoES/f4j4AhRE20jsPCF5pm+A==", - "dev": true, - "license": "MIT" + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@cspell/dict-companies/-/dict-companies-3.1.12.tgz", + "integrity": "sha512-99FxBNdLOQc3nVQ663Xh7JqDLbIy/AdqOecQ5bk3HpmXpSkoDvTT7XCUU5nQZvmFBrrQlXFKlRRYjLfTEOUDdA==", + "dev": true }, "node_modules/@cspell/dict-cpp": { - "version": "6.0.2", - "resolved": "https://registry.npmjs.org/@cspell/dict-cpp/-/dict-cpp-6.0.2.tgz", - "integrity": "sha512-yw5eejWvY4bAnc6LUA44m4WsFwlmgPt2uMSnO7QViGMBDuoeopMma4z9XYvs4lSjTi8fIJs/A1YDfM9AVzb8eg==", - "dev": true, - "license": "MIT" + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/@cspell/dict-cpp/-/dict-cpp-6.0.3.tgz", + "integrity": "sha512-OFrVXdxCeGKnon36Pe3yFjBuY4kzzEwWFf3vDz+cJTodZDkjFkBifQeTtt5YfimgF8cfAJZXkBCsxjipAgmAiw==", + "dev": true }, "node_modules/@cspell/dict-cryptocurrencies": { - "version": "5.0.3", - "resolved": "https://registry.npmjs.org/@cspell/dict-cryptocurrencies/-/dict-cryptocurrencies-5.0.3.tgz", - "integrity": "sha512-bl5q+Mk+T3xOZ12+FG37dB30GDxStza49Rmoax95n37MTLksk9wBo1ICOlPJ6PnDUSyeuv4SIVKgRKMKkJJglA==", - "dev": true, - "license": "MIT" + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/@cspell/dict-cryptocurrencies/-/dict-cryptocurrencies-5.0.4.tgz", + "integrity": "sha512-6iFu7Abu+4Mgqq08YhTKHfH59mpMpGTwdzDB2Y8bbgiwnGFCeoiSkVkgLn1Kel2++hYcZ8vsAW/MJS9oXxuMag==", + "dev": true }, "node_modules/@cspell/dict-csharp": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/@cspell/dict-csharp/-/dict-csharp-4.0.5.tgz", - "integrity": "sha512-c/sFnNgtRwRJxtC3JHKkyOm+U3/sUrltFeNwml9VsxKBHVmvlg4tk4ar58PdpW9/zTlGUkWi2i85//DN1EsUCA==", - "dev": true, - "license": "MIT" + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/@cspell/dict-csharp/-/dict-csharp-4.0.6.tgz", + "integrity": "sha512-w/+YsqOknjQXmIlWDRmkW+BHBPJZ/XDrfJhZRQnp0wzpPOGml7W0q1iae65P2AFRtTdPKYmvSz7AL5ZRkCnSIw==", + "dev": true }, "node_modules/@cspell/dict-css": { - "version": "4.0.16", - "resolved": "https://registry.npmjs.org/@cspell/dict-css/-/dict-css-4.0.16.tgz", - "integrity": "sha512-70qu7L9z/JR6QLyJPk38fNTKitlIHnfunx0wjpWQUQ8/jGADIhMCrz6hInBjqPNdtGpYm8d1dNFyF8taEkOgrQ==", - "dev": true, - "license": "MIT" + "version": "4.0.17", + "resolved": "https://registry.npmjs.org/@cspell/dict-css/-/dict-css-4.0.17.tgz", + "integrity": "sha512-2EisRLHk6X/PdicybwlajLGKF5aJf4xnX2uuG5lexuYKt05xV/J/OiBADmi8q9obhxf1nesrMQbqAt+6CsHo/w==", + "dev": true }, "node_modules/@cspell/dict-dart": { - "version": "2.2.4", - "resolved": "https://registry.npmjs.org/@cspell/dict-dart/-/dict-dart-2.2.4.tgz", - "integrity": "sha512-of/cVuUIZZK/+iqefGln8G3bVpfyN6ZtH+LyLkHMoR5tEj+2vtilGNk9ngwyR8L4lEqbKuzSkOxgfVjsXf5PsQ==", - "dev": true, - "license": "MIT" + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/@cspell/dict-dart/-/dict-dart-2.2.5.tgz", + "integrity": "sha512-j/J99MH4NV2Klok0XMqnHxGl2lkewBcYjGYWdBKvVSbLXyA4oOaL+vCZR8Nmwf+lHInJFN8nkMU2k7TnC0MgUw==", + "dev": true }, "node_modules/@cspell/dict-data-science": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@cspell/dict-data-science/-/dict-data-science-2.0.5.tgz", - "integrity": "sha512-nNSILXmhSJox9/QoXICPQgm8q5PbiSQP4afpbkBqPi/u/b3K9MbNH5HvOOa6230gxcGdbZ9Argl2hY/U8siBlg==", - "dev": true, - "license": "MIT" + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@cspell/dict-data-science/-/dict-data-science-2.0.6.tgz", + "integrity": "sha512-gOYKZOg358yhnnQfr1/f232REmjeIymXUHJdrLEMPirluv2rzMWvEBBazqRVQ++jMUNg9IduVI0v096ZWMDekA==", + "dev": true }, "node_modules/@cspell/dict-django": { - "version": "4.1.3", - "resolved": "https://registry.npmjs.org/@cspell/dict-django/-/dict-django-4.1.3.tgz", - "integrity": "sha512-yBspeL3roJlO0a1vKKNaWABURuHdHZ9b1L8d3AukX0AsBy9snSggc8xCavPmSzNfeMDXbH+1lgQiYBd3IW03fg==", - "dev": true, - "license": "MIT" + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/@cspell/dict-django/-/dict-django-4.1.4.tgz", + "integrity": "sha512-fX38eUoPvytZ/2GA+g4bbdUtCMGNFSLbdJJPKX2vbewIQGfgSFJKY56vvcHJKAvw7FopjvgyS/98Ta9WN1gckg==", + "dev": true }, "node_modules/@cspell/dict-docker": { - "version": "1.1.11", - "resolved": "https://registry.npmjs.org/@cspell/dict-docker/-/dict-docker-1.1.11.tgz", - "integrity": "sha512-s0Yhb16/R+UT1y727ekbR/itWQF3Qz275DR1ahOa66wYtPjHUXmhM3B/LT3aPaX+hD6AWmK23v57SuyfYHUjsw==", - "dev": true, - "license": "MIT" + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/@cspell/dict-docker/-/dict-docker-1.1.12.tgz", + "integrity": "sha512-6d25ZPBnYZaT9D9An/x6g/4mk542R8bR3ipnby3QFCxnfdd6xaWiTcwDPsCgwN2aQZIQ1jX/fil9KmBEqIK/qA==", + "dev": true }, "node_modules/@cspell/dict-dotnet": { - "version": "5.0.8", - "resolved": "https://registry.npmjs.org/@cspell/dict-dotnet/-/dict-dotnet-5.0.8.tgz", - "integrity": "sha512-MD8CmMgMEdJAIPl2Py3iqrx3B708MbCIXAuOeZ0Mzzb8YmLmiisY7QEYSZPg08D7xuwARycP0Ki+bb0GAkFSqg==", - "dev": true, - "license": "MIT" + "version": "5.0.9", + "resolved": "https://registry.npmjs.org/@cspell/dict-dotnet/-/dict-dotnet-5.0.9.tgz", + "integrity": "sha512-JGD6RJW5sHtO5lfiJl11a5DpPN6eKSz5M1YBa1I76j4dDOIqgZB6rQexlDlK1DH9B06X4GdDQwdBfnpAB0r2uQ==", + "dev": true }, "node_modules/@cspell/dict-elixir": { - "version": "4.0.6", - "resolved": "https://registry.npmjs.org/@cspell/dict-elixir/-/dict-elixir-4.0.6.tgz", - "integrity": "sha512-TfqSTxMHZ2jhiqnXlVKM0bUADtCvwKQv2XZL/DI0rx3doG8mEMS8SGPOmiyyGkHpR/pGOq18AFH3BEm4lViHIw==", - "dev": true, - "license": "MIT" + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/@cspell/dict-elixir/-/dict-elixir-4.0.7.tgz", + "integrity": "sha512-MAUqlMw73mgtSdxvbAvyRlvc3bYnrDqXQrx5K9SwW8F7fRYf9V4vWYFULh+UWwwkqkhX9w03ZqFYRTdkFku6uA==", + "dev": true }, "node_modules/@cspell/dict-en_us": { - "version": "4.3.27", - "resolved": "https://registry.npmjs.org/@cspell/dict-en_us/-/dict-en_us-4.3.27.tgz", - "integrity": "sha512-7JYHahRWpi0VykWFTSM03KL/0fs6YtYfpOaTAg4N/d0wB2GfwVG/FJ/SBCjD4LBc6Rx9dzdo95Hs4BB8GPQbOA==", - "dev": true, - "license": "MIT" + "version": "4.3.28", + "resolved": "https://registry.npmjs.org/@cspell/dict-en_us/-/dict-en_us-4.3.28.tgz", + "integrity": "sha512-BN1PME7cOl7DXRQJ92pEd1f0Xk5sqjcDfThDGkKcsgwbSOY7KnTc/czBW6Pr3WXIchIm6cT12KEfjNqx7U7Rrw==", + "dev": true }, "node_modules/@cspell/dict-en-common-misspellings": { - "version": "2.0.7", - "resolved": "https://registry.npmjs.org/@cspell/dict-en-common-misspellings/-/dict-en-common-misspellings-2.0.7.tgz", - "integrity": "sha512-qNFo3G4wyabcwnM+hDrMYKN9vNVg/k9QkhqSlSst6pULjdvPyPs1mqz1689xO/v9t8e6sR4IKc3CgUXDMTYOpA==", - "dev": true, - "license": "CC BY-SA 4.0" + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/@cspell/dict-en-common-misspellings/-/dict-en-common-misspellings-2.0.8.tgz", + "integrity": "sha512-l1u/pDjwrPyWwBd1hCkZhdsK8yLbLFPD2xWz+1tFFI7WaV9ckDZoF3woRc/0wFGRy53yrfSAVuwhoYOQnHe/fA==", + "dev": true }, "node_modules/@cspell/dict-en-gb": { "version": "1.1.33", "resolved": "https://registry.npmjs.org/@cspell/dict-en-gb/-/dict-en-gb-1.1.33.tgz", "integrity": "sha512-tKSSUf9BJEV+GJQAYGw5e+ouhEe2ZXE620S7BLKe3ZmpnjlNG9JqlnaBhkIMxKnNFkLY2BP/EARzw31AZnOv4g==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/@cspell/dict-filetypes": { - "version": "3.0.8", - "resolved": "https://registry.npmjs.org/@cspell/dict-filetypes/-/dict-filetypes-3.0.8.tgz", - "integrity": "sha512-D3N8sm/iptzfVwsib/jvpX+K/++rM8SRpLDFUaM4jxm8EyGmSIYRbKZvdIv5BkAWmMlTWoRqlLn7Yb1b11jKJg==", - "dev": true, - "license": "MIT" + "version": "3.0.10", + "resolved": "https://registry.npmjs.org/@cspell/dict-filetypes/-/dict-filetypes-3.0.10.tgz", + "integrity": "sha512-JEN3627joBVtpa1yfkdN9vz1Z129PoKGHBKjXCEziJvf2Zt1LeULWYYYg/O6pzRR4yzRa5YbXDTuyrN7vX7DFg==", + "dev": true }, "node_modules/@cspell/dict-flutter": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/@cspell/dict-flutter/-/dict-flutter-1.0.3.tgz", - "integrity": "sha512-52C9aUEU22ptpgYh6gQyIdA4MP6NPwzbEqndfgPh3Sra191/kgs7CVqXiO1qbtZa9gnYHUoVApkoxRE7mrXHfg==", - "dev": true, - "license": "MIT" + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@cspell/dict-flutter/-/dict-flutter-1.0.4.tgz", + "integrity": "sha512-XlWLCUsI9m2rKJ5TqYcDucajzQOqa7Hy8dhHaRQEyWic6oYvikpA1KtXsi8JD6JaiqfhejZZ6vNsQm1//6iSAg==", + "dev": true }, "node_modules/@cspell/dict-fonts": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/@cspell/dict-fonts/-/dict-fonts-4.0.3.tgz", - "integrity": "sha512-sPd17kV5qgYXLteuHFPn5mbp/oCHKgitNfsZLFC3W2fWEgZlhg4hK+UGig3KzrYhhvQ8wBnmZrAQm0TFKCKzsA==", - "dev": true, - "license": "MIT" + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@cspell/dict-fonts/-/dict-fonts-4.0.4.tgz", + "integrity": "sha512-cHFho4hjojBcHl6qxidl9CvUb492IuSk7xIf2G2wJzcHwGaCFa2o3gRcxmIg1j62guetAeDDFELizDaJlVRIOg==", + "dev": true }, "node_modules/@cspell/dict-fsharp": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/@cspell/dict-fsharp/-/dict-fsharp-1.0.4.tgz", - "integrity": "sha512-G5wk0o1qyHUNi9nVgdE1h5wl5ylq7pcBjX8vhjHcO4XBq20D5eMoXjwqMo/+szKAqzJ+WV3BgAL50akLKrT9Rw==", - "dev": true, - "license": "MIT" + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@cspell/dict-fsharp/-/dict-fsharp-1.0.5.tgz", + "integrity": "sha512-6SsdHOtUsTDZ50wjK4FcvIjPiwBSDU9M/+zmUWpFfT5k5d5Ei80n4HGisFtuFdtmoLgz2F/xNnVvhsA2MWJv+w==", + "dev": true }, "node_modules/@cspell/dict-fullstack": { "version": "3.2.3", "resolved": "https://registry.npmjs.org/@cspell/dict-fullstack/-/dict-fullstack-3.2.3.tgz", "integrity": "sha512-62PbndIyQPH11mAv0PyiyT0vbwD0AXEocPpHlCHzfb5v9SspzCCbzQ/LIBiFmyRa+q5LMW35CnSVu6OXdT+LKg==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/@cspell/dict-gaming-terms": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/@cspell/dict-gaming-terms/-/dict-gaming-terms-1.0.8.tgz", - "integrity": "sha512-7OL0zTl93WFWhhtpXFrtm9uZXItC3ncAs8d0iQDMMFVNU1rBr6raBNxJskxE5wx2Ant12fgI66ZGVagXfN+yfA==", - "dev": true, - "license": "MIT" + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@cspell/dict-gaming-terms/-/dict-gaming-terms-1.0.10.tgz", + "integrity": "sha512-LJBUSg2ErWi5+QQysFKFwRvq09zAswteIKdAM/g06NpSiPT+SoIeRNKnnASmvuQQSFS427EwgKKtJ3723n2SFQ==", + "dev": true }, "node_modules/@cspell/dict-git": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@cspell/dict-git/-/dict-git-3.0.3.tgz", - "integrity": "sha512-LSxB+psZ0qoj83GkyjeEH/ZViyVsGEF/A6BAo8Nqc0w0HjD2qX/QR4sfA6JHUgQ3Yi/ccxdK7xNIo67L2ScW5A==", - "dev": true, - "license": "MIT" + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@cspell/dict-git/-/dict-git-3.0.4.tgz", + "integrity": "sha512-C44M+m56rYn6QCsLbiKiedyPTMZxlDdEYAsPwwlL5bhMDDzXZ3Ic8OCQIhMbiunhCOJJT+er4URmOmM+sllnjg==", + "dev": true }, "node_modules/@cspell/dict-golang": { - "version": "6.0.17", - "resolved": "https://registry.npmjs.org/@cspell/dict-golang/-/dict-golang-6.0.17.tgz", - "integrity": "sha512-uDDLEJ/cHdLiqPw4+5BnmIo2i/TSR+uDvYd6JlBjTmjBKpOCyvUgYRztH7nv5e7virsN5WDiUWah4/ATQGz4Pw==", - "dev": true, - "license": "MIT" + "version": "6.0.18", + "resolved": "https://registry.npmjs.org/@cspell/dict-golang/-/dict-golang-6.0.18.tgz", + "integrity": "sha512-Mt+7NwfodDwUk7423DdaQa0YaA+4UoV3XSxQwZioqjpFBCuxfvvv4l80MxCTAAbK6duGj0uHbGTwpv8fyKYPKg==", + "dev": true }, "node_modules/@cspell/dict-google": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/@cspell/dict-google/-/dict-google-1.0.4.tgz", - "integrity": "sha512-JThUT9eiguCja1mHHLwYESgxkhk17Gv7P3b1S7ZJzXw86QyVHPrbpVoMpozHk0C9o+Ym764B7gZGKmw9uMGduQ==", - "dev": true, - "license": "MIT" + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@cspell/dict-google/-/dict-google-1.0.5.tgz", + "integrity": "sha512-KNrzfUsoFat94slWzo36g601sIGz6KtE4kBMM0gpqwFLK/MXRyaW65IL4SwysY0PEhuRzg9spLLMnUXuVcY2hQ==", + "dev": true }, "node_modules/@cspell/dict-haskell": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/@cspell/dict-haskell/-/dict-haskell-4.0.4.tgz", - "integrity": "sha512-EwQsedEEnND/vY6tqRfg9y7tsnZdxNqOxLXSXTsFA6JRhUlr8Qs88iUUAfsUzWc4nNmmzQH2UbtT25ooG9x4nA==", - "dev": true, - "license": "MIT" + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/@cspell/dict-haskell/-/dict-haskell-4.0.5.tgz", + "integrity": "sha512-s4BG/4tlj2pPM9Ha7IZYMhUujXDnI0Eq1+38UTTCpatYLbQqDwRFf2KNPLRqkroU+a44yTUAe0rkkKbwy4yRtQ==", + "dev": true }, "node_modules/@cspell/dict-html": { - "version": "4.0.10", - "resolved": "https://registry.npmjs.org/@cspell/dict-html/-/dict-html-4.0.10.tgz", - "integrity": "sha512-I9uRAcdtHbh0wEtYZlgF0TTcgH0xaw1B54G2CW+tx4vHUwlde/+JBOfIzird4+WcMv4smZOfw+qHf7puFUbI5g==", - "dev": true, - "license": "MIT" + "version": "4.0.11", + "resolved": "https://registry.npmjs.org/@cspell/dict-html/-/dict-html-4.0.11.tgz", + "integrity": "sha512-QR3b/PB972SRQ2xICR1Nw/M44IJ6rjypwzA4jn+GH8ydjAX9acFNfc+hLZVyNe0FqsE90Gw3evLCOIF0vy1vQw==", + "dev": true }, "node_modules/@cspell/dict-html-symbol-entities": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/@cspell/dict-html-symbol-entities/-/dict-html-symbol-entities-4.0.3.tgz", "integrity": "sha512-aABXX7dMLNFdSE8aY844X4+hvfK7977sOWgZXo4MTGAmOzR8524fjbJPswIBK7GaD3+SgFZ2yP2o0CFvXDGF+A==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/@cspell/dict-java": { - "version": "5.0.10", - "resolved": "https://registry.npmjs.org/@cspell/dict-java/-/dict-java-5.0.10.tgz", - "integrity": "sha512-pVNcOnmoGiNL8GSVq4WbX/Vs2FGS0Nej+1aEeGuUY9CU14X8yAVCG+oih5ZoLt1jaR8YfR8byUF8wdp4qG4XIw==", - "dev": true, - "license": "MIT" + "version": "5.0.11", + "resolved": "https://registry.npmjs.org/@cspell/dict-java/-/dict-java-5.0.11.tgz", + "integrity": "sha512-T4t/1JqeH33Raa/QK/eQe26FE17eUCtWu+JsYcTLkQTci2dk1DfcIKo8YVHvZXBnuM43ATns9Xs0s+AlqDeH7w==", + "dev": true }, "node_modules/@cspell/dict-julia": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/@cspell/dict-julia/-/dict-julia-1.0.4.tgz", - "integrity": "sha512-bFVgNX35MD3kZRbXbJVzdnN7OuEqmQXGpdOi9jzB40TSgBTlJWA4nxeAKV4CPCZxNRUGnLH0p05T/AD7Aom9/w==", - "dev": true, - "license": "MIT" + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@cspell/dict-julia/-/dict-julia-1.0.5.tgz", + "integrity": "sha512-rMC9OC8POmGw9pN96ByZJaY0YGtzSh64AtuJu4uFcuooF0MGmtXwiAhazRC5kPK5XMS+pKMQql/ItTyKbYh1yg==", + "dev": true }, "node_modules/@cspell/dict-k8s": { - "version": "1.0.9", - "resolved": "https://registry.npmjs.org/@cspell/dict-k8s/-/dict-k8s-1.0.9.tgz", - "integrity": "sha512-Q7GELSQIzo+BERl2ya/nBEnZeQC+zJP19SN1pI6gqDYraM51uYJacbbcWLYYO2Y+5joDjNt/sd/lJtLaQwoSlA==", - "dev": true, - "license": "MIT" + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@cspell/dict-k8s/-/dict-k8s-1.0.10.tgz", + "integrity": "sha512-313haTrX9prep1yWO7N6Xw4D6tvUJ0Xsx+YhCP+5YrrcIKoEw5Rtlg8R4PPzLqe6zibw6aJ+Eqq+y76Vx5BZkw==", + "dev": true }, "node_modules/@cspell/dict-latex": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/@cspell/dict-latex/-/dict-latex-4.0.3.tgz", "integrity": "sha512-2KXBt9fSpymYHxHfvhUpjUFyzrmN4c4P8mwIzweLyvqntBT3k0YGZJSriOdjfUjwSygrfEwiuPI1EMrvgrOMJw==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/@cspell/dict-lorem-ipsum": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/@cspell/dict-lorem-ipsum/-/dict-lorem-ipsum-4.0.3.tgz", - "integrity": "sha512-WFpDi/PDYHXft6p0eCXuYnn7mzMEQLVeqpO+wHSUd+kz5ADusZ4cpslAA4wUZJstF1/1kMCQCZM6HLZic9bT8A==", - "dev": true, - "license": "MIT" + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@cspell/dict-lorem-ipsum/-/dict-lorem-ipsum-4.0.4.tgz", + "integrity": "sha512-+4f7vtY4dp2b9N5fn0za/UR0kwFq2zDtA62JCbWHbpjvO9wukkbl4rZg4YudHbBgkl73HRnXFgCiwNhdIA1JPw==", + "dev": true }, "node_modules/@cspell/dict-lua": { - "version": "4.0.6", - "resolved": "https://registry.npmjs.org/@cspell/dict-lua/-/dict-lua-4.0.6.tgz", - "integrity": "sha512-Jwvh1jmAd9b+SP9e1GkS2ACbqKKRo9E1f9GdjF/ijmooZuHU0hPyqvnhZzUAxO1egbnNjxS/J2T6iUtjAUK2KQ==", - "dev": true, - "license": "MIT" + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/@cspell/dict-lua/-/dict-lua-4.0.7.tgz", + "integrity": "sha512-Wbr7YSQw+cLHhTYTKV6cAljgMgcY+EUAxVIZW3ljKswEe4OLxnVJ7lPqZF5JKjlXdgCjbPSimsHqyAbC5pQN/Q==", + "dev": true }, "node_modules/@cspell/dict-makefile": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/@cspell/dict-makefile/-/dict-makefile-1.0.3.tgz", - "integrity": "sha512-R3U0DSpvTs6qdqfyBATnePj9Q/pypkje0Nj26mQJ8TOBQutCRAJbr2ZFAeDjgRx5EAJU/+8txiyVF97fbVRViw==", - "dev": true, - "license": "MIT" + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@cspell/dict-makefile/-/dict-makefile-1.0.4.tgz", + "integrity": "sha512-E4hG/c0ekPqUBvlkrVvzSoAA+SsDA9bLi4xSV3AXHTVru7Y2bVVGMPtpfF+fI3zTkww/jwinprcU1LSohI3ylw==", + "dev": true }, "node_modules/@cspell/dict-markdown": { - "version": "2.0.7", - "resolved": "https://registry.npmjs.org/@cspell/dict-markdown/-/dict-markdown-2.0.7.tgz", - "integrity": "sha512-F9SGsSOokFn976DV4u/1eL4FtKQDSgJHSZ3+haPRU5ki6OEqojxKa8hhj4AUrtNFpmBaJx/WJ4YaEzWqG7hgqg==", + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/@cspell/dict-markdown/-/dict-markdown-2.0.8.tgz", + "integrity": "sha512-GCzfae+PLw9MjdgOO0OB67zguNfhiLnaZX1glCNJ6G1ZWqfeC9eBOxrAR3BkFXoBY0cvDSjIP037QXFEfCgeTg==", "dev": true, - "license": "MIT", "peerDependencies": { - "@cspell/dict-css": "^4.0.16", - "@cspell/dict-html": "^4.0.10", + "@cspell/dict-css": "^4.0.17", + "@cspell/dict-html": "^4.0.11", "@cspell/dict-html-symbol-entities": "^4.0.3", - "@cspell/dict-typescript": "^3.1.11" + "@cspell/dict-typescript": "^3.1.12" } }, "node_modules/@cspell/dict-monkeyc": { - "version": "1.0.9", - "resolved": "https://registry.npmjs.org/@cspell/dict-monkeyc/-/dict-monkeyc-1.0.9.tgz", - "integrity": "sha512-Jvf6g5xlB4+za3ThvenYKREXTEgzx5gMUSzrAxIiPleVG4hmRb/GBSoSjtkGaibN3XxGx5x809gSTYCA/IHCpA==", - "dev": true, - "license": "MIT" + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@cspell/dict-monkeyc/-/dict-monkeyc-1.0.10.tgz", + "integrity": "sha512-7RTGyKsTIIVqzbvOtAu6Z/lwwxjGRtY5RkKPlXKHEoEAgIXwfDxb5EkVwzGQwQr8hF/D3HrdYbRT8MFBfsueZw==", + "dev": true }, "node_modules/@cspell/dict-node": { - "version": "5.0.5", - "resolved": "https://registry.npmjs.org/@cspell/dict-node/-/dict-node-5.0.5.tgz", - "integrity": "sha512-7NbCS2E8ZZRZwlLrh2sA0vAk9n1kcTUiRp/Nia8YvKaItGXLfxYqD2rMQ3HpB1kEutal6hQLVic3N2Yi1X7AaA==", - "dev": true, - "license": "MIT" + "version": "5.0.6", + "resolved": "https://registry.npmjs.org/@cspell/dict-node/-/dict-node-5.0.6.tgz", + "integrity": "sha512-CEbhPCpxGvRNByGolSBTrXXW2rJA4bGqZuTx1KKO85mwR6aadeOmUE7xf/8jiCkXSy+qvr9aJeh+jlfXcsrziQ==", + "dev": true }, "node_modules/@cspell/dict-npm": { - "version": "5.1.13", - "resolved": "https://registry.npmjs.org/@cspell/dict-npm/-/dict-npm-5.1.13.tgz", - "integrity": "sha512-7S1Pwq16M4sqvv/op7iHErc6Diz+DXsBYRMS0dDj6HUS44VXMvgejXa3RMd5jwBmcHzkInFm3DW1eb2exBs0cg==", - "dev": true, - "license": "MIT" + "version": "5.1.21", + "resolved": "https://registry.npmjs.org/@cspell/dict-npm/-/dict-npm-5.1.21.tgz", + "integrity": "sha512-AHqgbnBPwdMUF6jV/vyf5lz1+9MpmQn8h2E/Px0jHYFri4VTZ5TNBa40NaTNC/L/U/ggbVQTSoBnqZ6rLFwGCg==", + "dev": true }, "node_modules/@cspell/dict-php": { - "version": "4.0.13", - "resolved": "https://registry.npmjs.org/@cspell/dict-php/-/dict-php-4.0.13.tgz", - "integrity": "sha512-P6sREMZkhElzz/HhXAjahnICYIqB/HSGp1EhZh+Y6IhvC15AzgtDP8B8VYCIsQof6rPF1SQrFwunxOv8H1e2eg==", - "dev": true, - "license": "MIT" + "version": "4.0.14", + "resolved": "https://registry.npmjs.org/@cspell/dict-php/-/dict-php-4.0.14.tgz", + "integrity": "sha512-7zur8pyncYZglxNmqsRycOZ6inpDoVd4yFfz1pQRe5xaRWMiK3Km4n0/X/1YMWhh3e3Sl/fQg5Axb2hlN68t1g==", + "dev": true }, "node_modules/@cspell/dict-powershell": { - "version": "5.0.13", - "resolved": "https://registry.npmjs.org/@cspell/dict-powershell/-/dict-powershell-5.0.13.tgz", - "integrity": "sha512-0qdj0XZIPmb77nRTynKidRJKTU0Fl+10jyLbAhFTuBWKMypVY06EaYFnwhsgsws/7nNX8MTEQuewbl9bWFAbsg==", - "dev": true, - "license": "MIT" + "version": "5.0.14", + "resolved": "https://registry.npmjs.org/@cspell/dict-powershell/-/dict-powershell-5.0.14.tgz", + "integrity": "sha512-ktjjvtkIUIYmj/SoGBYbr3/+CsRGNXGpvVANrY0wlm/IoGlGywhoTUDYN0IsGwI2b8Vktx3DZmQkfb3Wo38jBA==", + "dev": true }, "node_modules/@cspell/dict-public-licenses": { - "version": "2.0.11", - "resolved": "https://registry.npmjs.org/@cspell/dict-public-licenses/-/dict-public-licenses-2.0.11.tgz", - "integrity": "sha512-rR5KjRUSnVKdfs5G+gJ4oIvQvm8+NJ6cHWY2N+GE69/FSGWDOPHxulCzeGnQU/c6WWZMSimG9o49i9r//lUQyA==", - "dev": true, - "license": "MIT" + "version": "2.0.12", + "resolved": "https://registry.npmjs.org/@cspell/dict-public-licenses/-/dict-public-licenses-2.0.12.tgz", + "integrity": "sha512-obreJMVbz8ZrXyc60PcS/B2FwXaO3AWPO2x50zrI/n4UDuBr/UdPb6M1q++6c08n+151I35GEx52xRFiToSg4g==", + "dev": true }, "node_modules/@cspell/dict-python": { - "version": "4.2.12", - "resolved": "https://registry.npmjs.org/@cspell/dict-python/-/dict-python-4.2.12.tgz", - "integrity": "sha512-U25eOFu+RE0aEcF2AsxZmq3Lic7y9zspJ9SzjrC0mfJz+yr3YmSCw4E0blMD3mZoNcf7H/vMshuKIY5AY36U+Q==", + "version": "4.2.14", + "resolved": "https://registry.npmjs.org/@cspell/dict-python/-/dict-python-4.2.14.tgz", + "integrity": "sha512-NZ/rsTH5gqTlEwbSg0vn5b1TsyzrUvA6ykwCVCwsVDdlQAS82cyDsF9JqHp8S4d6PFykmkfSxtAXYyOUr0KCbg==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/dict-data-science": "^2.0.5" + "@cspell/dict-data-science": "^2.0.6" } }, "node_modules/@cspell/dict-r": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/@cspell/dict-r/-/dict-r-2.0.4.tgz", - "integrity": "sha512-cBpRsE/U0d9BRhiNRMLMH1PpWgw+N+1A2jumgt1if9nBGmQw4MUpg2u9I0xlFVhstTIdzXiLXMxP45cABuiUeQ==", - "dev": true, - "license": "MIT" + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@cspell/dict-r/-/dict-r-2.0.5.tgz", + "integrity": "sha512-CpZvA/6Ps/vCaR5c+2tL1dGU7ZlIFMp+lUamamHGG1ZIc0+j+16Tb1+9oksEf7k8LCI/F5Io4uIJ+0NezaY8Rg==", + "dev": true }, "node_modules/@cspell/dict-ruby": { "version": "5.0.7", "resolved": "https://registry.npmjs.org/@cspell/dict-ruby/-/dict-ruby-5.0.7.tgz", "integrity": "sha512-4/d0hcoPzi5Alk0FmcyqlzFW9lQnZh9j07MJzPcyVO62nYJJAGKaPZL2o4qHeCS/od/ctJC5AHRdoUm0ktsw6Q==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/@cspell/dict-rust": { - "version": "4.0.10", - "resolved": "https://registry.npmjs.org/@cspell/dict-rust/-/dict-rust-4.0.10.tgz", - "integrity": "sha512-6o5C8566VGTTctgcwfF3Iy7314W0oMlFFSQOadQ0OEdJ9Z9ERX/PDimrzP3LGuOrvhtEFoK8pj+BLnunNwRNrw==", - "dev": true, - "license": "MIT" + "version": "4.0.11", + "resolved": "https://registry.npmjs.org/@cspell/dict-rust/-/dict-rust-4.0.11.tgz", + "integrity": "sha512-OGWDEEzm8HlkSmtD8fV3pEcO2XBpzG2XYjgMCJCRwb2gRKvR+XIm6Dlhs04N/K2kU+iH8bvrqNpM8fS/BFl0uw==", + "dev": true }, "node_modules/@cspell/dict-scala": { - "version": "5.0.6", - "resolved": "https://registry.npmjs.org/@cspell/dict-scala/-/dict-scala-5.0.6.tgz", - "integrity": "sha512-tl0YWAfjUVb4LyyE4JIMVE8DlLzb1ecHRmIWc4eT6nkyDqQgHKzdHsnusxFEFMVLIQomgSg0Zz6hJ5S1E4W4ww==", - "dev": true, - "license": "MIT" + "version": "5.0.7", + "resolved": "https://registry.npmjs.org/@cspell/dict-scala/-/dict-scala-5.0.7.tgz", + "integrity": "sha512-yatpSDW/GwulzO3t7hB5peoWwzo+Y3qTc0pO24Jf6f88jsEeKmDeKkfgPbYuCgbE4jisGR4vs4+jfQZDIYmXPA==", + "dev": true }, "node_modules/@cspell/dict-software-terms": { - "version": "4.1.17", - "resolved": "https://registry.npmjs.org/@cspell/dict-software-terms/-/dict-software-terms-4.1.17.tgz", - "integrity": "sha512-QORIk1R5DV8oOQ+oAlUWE7UomaJwUucqu2srrc2+PmkoI6R1fJwwg2uHCPBWlIb4PGDNEdXLv9BAD13H+0wytQ==", - "dev": true, - "license": "MIT" + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@cspell/dict-software-terms/-/dict-software-terms-4.2.2.tgz", + "integrity": "sha512-cgteXRzx2W/Ug7QSdFJrVxLES7krrZEjZ9J6sXRWOsVYFpgu2Gup8NKmjKOZ8NTnCjHQFrMnbmKdv56q9Kwixw==", + "dev": true }, "node_modules/@cspell/dict-sql": { - "version": "2.1.8", - "resolved": "https://registry.npmjs.org/@cspell/dict-sql/-/dict-sql-2.1.8.tgz", - "integrity": "sha512-dJRE4JV1qmXTbbGm6WIcg1knmR6K5RXnQxF4XHs5HA3LAjc/zf77F95i5LC+guOGppVF6Hdl66S2UyxT+SAF3A==", - "dev": true, - "license": "MIT" + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/@cspell/dict-sql/-/dict-sql-2.1.9.tgz", + "integrity": "sha512-dyVtWGUs79SihmxzoXXOpA2mRipQhzZOy5mrRTZvMp3HE7Y5vM1ag/Di8+QCtjYD6l7MjVjp0CxkKp1U7PBpbw==", + "dev": true }, "node_modules/@cspell/dict-svelte": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/@cspell/dict-svelte/-/dict-svelte-1.0.5.tgz", - "integrity": "sha512-sseHlcXOqWE4Ner9sg8KsjxwSJ2yssoJNqFHR9liWVbDV+m7kBiUtn2EB690TihzVsEmDr/0Yxrbb5Bniz70mA==", - "dev": true, - "license": "MIT" + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@cspell/dict-svelte/-/dict-svelte-1.0.6.tgz", + "integrity": "sha512-8LAJHSBdwHCoKCSy72PXXzz7ulGROD0rP1CQ0StOqXOOlTUeSFaJJlxNYjlONgd2c62XBQiN2wgLhtPN+1Zv7Q==", + "dev": true }, "node_modules/@cspell/dict-swift": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/@cspell/dict-swift/-/dict-swift-2.0.4.tgz", - "integrity": "sha512-CsFF0IFAbRtYNg0yZcdaYbADF5F3DsM8C4wHnZefQy8YcHP/qjAF/GdGfBFBLx+XSthYuBlo2b2XQVdz3cJZBw==", - "dev": true, - "license": "MIT" + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@cspell/dict-swift/-/dict-swift-2.0.5.tgz", + "integrity": "sha512-3lGzDCwUmnrfckv3Q4eVSW3sK3cHqqHlPprFJZD4nAqt23ot7fic5ALR7J4joHpvDz36nHX34TgcbZNNZOC/JA==", + "dev": true }, "node_modules/@cspell/dict-terraform": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/@cspell/dict-terraform/-/dict-terraform-1.0.6.tgz", - "integrity": "sha512-Sqm5vGbXuI9hCFcr4w6xWf4Y25J9SdleE/IqfM6RySPnk8lISEmVdax4k6+Kinv9qaxyvnIbUUN4WFLWcBPQAg==", - "dev": true, - "license": "MIT" + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@cspell/dict-terraform/-/dict-terraform-1.0.8.tgz", + "integrity": "sha512-YR2v2iDtuzEIwOWAlV9V8pdnrIQud6wHQOhuk3oqR3PS0rkAd6dkWrS0Ce2gbZY7AHHxQ2jvJ66pOjAdIDXbtA==", + "dev": true }, "node_modules/@cspell/dict-typescript": { - "version": "3.1.11", - "resolved": "https://registry.npmjs.org/@cspell/dict-typescript/-/dict-typescript-3.1.11.tgz", - "integrity": "sha512-FwvK5sKbwrVpdw0e9+1lVTl8FPoHYvfHRuQRQz2Ql5XkC0gwPPkpoyD1zYImjIyZRoYXk3yp9j8ss4iz7A7zoQ==", - "dev": true, - "license": "MIT" + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@cspell/dict-typescript/-/dict-typescript-3.1.12.tgz", + "integrity": "sha512-gQxryTuRrRW3whM7gASetOTcPVsDGxfVn/MoSX507rcsFdZTnX18+M6D4iE0sUtranF1MWscGPIm6J2gfL3Zxw==", + "dev": true }, "node_modules/@cspell/dict-vue": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@cspell/dict-vue/-/dict-vue-3.0.3.tgz", - "integrity": "sha512-akmYbrgAGumqk1xXALtDJcEcOMYBYMnkjpmGzH13Ozhq1mkPF4VgllFQlm1xYde+BUKNnzMgPEzxrL2qZllgYA==", - "dev": true, - "license": "MIT" + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@cspell/dict-vue/-/dict-vue-3.0.4.tgz", + "integrity": "sha512-0dPtI0lwHcAgSiQFx8CzvqjdoXROcH+1LyqgROCpBgppommWpVhbQ0eubnKotFEXgpUCONVkeZJ6Ql8NbTEu+w==", + "dev": true }, "node_modules/@cspell/dynamic-import": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/dynamic-import/-/dynamic-import-8.16.0.tgz", - "integrity": "sha512-FH+B5y71qfunagXiLSJhXP9h/Vwb1Z8Cc/hLmliGekw/Y8BuYknL86tMg9grXBYNmM0kifIv6ZesQl8Km/p/rA==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/dynamic-import/-/dynamic-import-8.17.1.tgz", + "integrity": "sha512-XQtr2olYOtqbg49E+8SISd6I5DzfxmsKINDn0ZgaTFeLalnNdF3ewDU4gOEbApIzGffRa1mW9t19MsiVrznSDw==", "dev": true, - "license": "MIT", "dependencies": { + "@cspell/url": "8.17.1", "import-meta-resolve": "^4.1.0" }, "engines": { @@ -1475,31 +1397,28 @@ } }, "node_modules/@cspell/filetypes": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/filetypes/-/filetypes-8.16.0.tgz", - "integrity": "sha512-u2Ub0uSwXFPJFvXhAO/0FZBj3sMr4CeYCiQwTUsdFRkRMFpbTc7Vf+a+aC2vIj6WcaWrYXrJy3NZF/yjqF6SGw==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/filetypes/-/filetypes-8.17.1.tgz", + "integrity": "sha512-AxYw6j7EPYtDFAFjwybjFpMc9waXQzurfBXmEVfQ5RQRlbylujLZWwR6GnMqofeNg4oGDUpEjcAZFrgdkvMQlA==", "dev": true, - "license": "MIT", "engines": { "node": ">=18" } }, "node_modules/@cspell/strong-weak-map": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/strong-weak-map/-/strong-weak-map-8.16.0.tgz", - "integrity": "sha512-R6N12wEIQpBk2uyni/FU1SFSIjP0uql7ynXVcF1ob8/JJeRoikssydi9Xq5J6ghMw+X50u35mFvg9BgWKz0d+g==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/strong-weak-map/-/strong-weak-map-8.17.1.tgz", + "integrity": "sha512-8cY3vLAKdt5gQEMM3Gr57BuQ8sun2NjYNh9qTdrctC1S9gNC7XzFghTYAfHSWR4VrOUcMFLO/izMdsc1KFvFOA==", "dev": true, - "license": "MIT", "engines": { "node": ">=18" } }, "node_modules/@cspell/url": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/@cspell/url/-/url-8.16.0.tgz", - "integrity": "sha512-zW+6hAieD/FjysfjY4mVv7iHWWasBP3ldj6L+xy2p4Kuax1nug7uuJqMHlAVude/OywNwENG0rYaP/P9Pg4O+w==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/@cspell/url/-/url-8.17.1.tgz", + "integrity": "sha512-LMvReIndW1ckvemElfDgTt282fb2C3C/ZXfsm0pJsTV5ZmtdelCHwzmgSBmY5fDr7D66XDp8EurotSE0K6BTvw==", "dev": true, - "license": "MIT", "engines": { "node": ">=18.0" } @@ -2350,7 +2269,6 @@ "resolved": "https://registry.npmjs.org/@manypkg/find-root/-/find-root-1.1.0.tgz", "integrity": "sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==", "dev": true, - "license": "MIT", "dependencies": { "@babel/runtime": "^7.5.5", "@types/node": "^12.7.1", @@ -2362,15 +2280,13 @@ "version": "12.20.55", "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.55.tgz", "integrity": "sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/@manypkg/find-root/node_modules/fs-extra": { "version": "8.1.0", "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", "dev": true, - "license": "MIT", "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^4.0.0", @@ -2385,7 +2301,6 @@ "resolved": "https://registry.npmjs.org/@manypkg/get-packages/-/get-packages-1.1.3.tgz", "integrity": "sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==", "dev": true, - "license": "MIT", "dependencies": { "@babel/runtime": "^7.5.5", "@changesets/types": "^4.0.1", @@ -2399,15 +2314,13 @@ "version": "4.1.0", "resolved": "https://registry.npmjs.org/@changesets/types/-/types-4.1.0.tgz", "integrity": "sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/@manypkg/get-packages/node_modules/fs-extra": { "version": "8.1.0", "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", "dev": true, - "license": "MIT", "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^4.0.0", @@ -2422,7 +2335,6 @@ "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", "dev": true, - "license": "MIT", "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" @@ -2436,7 +2348,6 @@ "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", "dev": true, - "license": "MIT", "engines": { "node": ">= 8" } @@ -2446,7 +2357,6 @@ "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", "dev": true, - "license": "MIT", "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" @@ -2781,11 +2691,10 @@ "dev": true }, "node_modules/@types/node": { - "version": "22.10.0", - "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.0.tgz", - "integrity": "sha512-XC70cRZVElFHfIUB40FgZOBbgJYFKKMa5nb9lxcwYstFG/Mi+/Y0bGS+rs6Dmhmkpq4pnNiLiuZAbc02YCOnmA==", + "version": "22.10.3", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.3.tgz", + "integrity": "sha512-DifAyw4BkrufCILvD3ucnuN8eydUfc/C1GlyrnI+LK6543w5/L3VeVgf05o3B4fqSXP1dKYLOZsKfutpxPzZrw==", "dev": true, - "license": "MIT", "dependencies": { "undici-types": "~6.20.0" } @@ -2927,15 +2836,13 @@ "version": "1.0.3", "resolved": "https://registry.npmjs.org/array-timsort/-/array-timsort-1.0.3.tgz", "integrity": "sha512-/+3GRL7dDAGEfM6TseQk/U+mi18TU2Ms9I3UlLdUMhz2hbvGNTKdj9xniwXfUqgYhHxRx0+8UnKkvlNwVU+cWQ==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/array-union": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", "dev": true, - "license": "MIT", "engines": { "node": ">=8" } @@ -3180,7 +3087,6 @@ "resolved": "https://registry.npmjs.org/better-path-resolve/-/better-path-resolve-1.0.0.tgz", "integrity": "sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==", "dev": true, - "license": "MIT", "dependencies": { "is-windows": "^1.0.0" }, @@ -3443,7 +3349,6 @@ "resolved": "https://registry.npmjs.org/clear-module/-/clear-module-4.1.2.tgz", "integrity": "sha512-LWAxzHqdHsAZlPlEyJ2Poz6AIs384mPeqLVCru2p0BrP9G/kVGuhNyZYClLO6cXlnuJjzC8xtsJIuMjKqLXoAw==", "dev": true, - "license": "MIT", "dependencies": { "parent-module": "^2.0.0", "resolve-from": "^5.0.0" @@ -3514,7 +3419,6 @@ "resolved": "https://registry.npmjs.org/comment-json/-/comment-json-4.2.5.tgz", "integrity": "sha512-bKw/r35jR3HGt5PEPm1ljsQQGyCrR8sFGNiN5L+ykDHdpO8Smxkrkla9Yi6NkQyUrb8V54PGhfMs6NrIwtxtdw==", "dev": true, - "license": "MIT", "dependencies": { "array-timsort": "^1.0.3", "core-util-is": "^1.0.3", @@ -3542,8 +3446,7 @@ "version": "1.0.3", "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/create-jest": { "version": "29.7.0", @@ -3658,25 +3561,24 @@ } }, "node_modules/cspell": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/cspell/-/cspell-8.16.0.tgz", - "integrity": "sha512-U6Up/4nODE+Ca+zqwZXTgBioGuF2JQHLEUIuoRJkJzAZkIBYDqrMXM+zdSL9E39+xb9jAtr9kPAYJf1Eybgi9g==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/cspell/-/cspell-8.17.1.tgz", + "integrity": "sha512-D0lw8XTXrTycNzOn5DkfPJNUT00X53OgvFDm+0SzhBr1r+na8LEh3CnQ6zKYVU0fL0x8vU82vs4jmGjDho9mPg==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/cspell-json-reporter": "8.16.0", - "@cspell/cspell-pipe": "8.16.0", - "@cspell/cspell-types": "8.16.0", - "@cspell/dynamic-import": "8.16.0", - "@cspell/url": "8.16.0", + "@cspell/cspell-json-reporter": "8.17.1", + "@cspell/cspell-pipe": "8.17.1", + "@cspell/cspell-types": "8.17.1", + "@cspell/dynamic-import": "8.17.1", + "@cspell/url": "8.17.1", "chalk": "^5.3.0", "chalk-template": "^1.1.0", "commander": "^12.1.0", - "cspell-dictionary": "8.16.0", - "cspell-gitignore": "8.16.0", - "cspell-glob": "8.16.0", - "cspell-io": "8.16.0", - "cspell-lib": "8.16.0", + "cspell-dictionary": "8.17.1", + "cspell-gitignore": "8.17.1", + "cspell-glob": "8.17.1", + "cspell-io": "8.17.1", + "cspell-lib": "8.17.1", "fast-json-stable-stringify": "^2.1.0", "file-entry-cache": "^9.1.0", "get-stdin": "^9.0.0", @@ -3695,30 +3597,28 @@ } }, "node_modules/cspell-config-lib": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/cspell-config-lib/-/cspell-config-lib-8.16.0.tgz", - "integrity": "sha512-PGT6ohLtIYXYLIm+R5hTcTrF0dzj8e7WAUJSJe5WlV/7lrwVdwgWaliLcXtSSPmfxgczr6sndX9TMJ2IEmPrmg==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/cspell-config-lib/-/cspell-config-lib-8.17.1.tgz", + "integrity": "sha512-x1S7QWprgUcwuwiJB1Ng0ZTBC4G50qP9qQyg/aroMkcdMsHfk26E8jUGRPNt4ftHFzS4YMhwtXuJQ9IgRUuNPA==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/cspell-types": "8.16.0", + "@cspell/cspell-types": "8.17.1", "comment-json": "^4.2.5", - "yaml": "^2.6.0" + "yaml": "^2.6.1" }, "engines": { "node": ">=18" } }, "node_modules/cspell-dictionary": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/cspell-dictionary/-/cspell-dictionary-8.16.0.tgz", - "integrity": "sha512-Y3sN6ttLBKbu0dOLcduY641n5QP1srUvZkW4bOTnG455DbIZfilrP1El/2Hl0RS6hC8LN9PM4bsIm/2xgdbApA==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/cspell-dictionary/-/cspell-dictionary-8.17.1.tgz", + "integrity": "sha512-zSl9l3wii+x16yc2NVZl/+CMLeLBAiuEd5YoFkOYPcbTJnfPwdjMNcj71u7wBvNJ+qwbF+kGbutEt15yHW3NBw==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/cspell-pipe": "8.16.0", - "@cspell/cspell-types": "8.16.0", - "cspell-trie-lib": "8.16.0", + "@cspell/cspell-pipe": "8.17.1", + "@cspell/cspell-types": "8.17.1", + "cspell-trie-lib": "8.17.1", "fast-equals": "^5.0.1" }, "engines": { @@ -3726,15 +3626,14 @@ } }, "node_modules/cspell-gitignore": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/cspell-gitignore/-/cspell-gitignore-8.16.0.tgz", - "integrity": "sha512-ODKe0ooyzYSBJkwgIVZSRIvzoZfT4tEbFt4fFDT88wPyyfX7xp7MAQhXy5KD1ocXH0WvYbdv37qzn2UbckrahA==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/cspell-gitignore/-/cspell-gitignore-8.17.1.tgz", + "integrity": "sha512-bk727Zf4FBCjm9Mwvyreyhgjwe+YhPQEW7PldkHiinKd+Irfez4s8GXLQb1EgV0UpvViqaqBqLmngjZdS30BTA==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/url": "8.16.0", - "cspell-glob": "8.16.0", - "cspell-io": "8.16.0", + "@cspell/url": "8.17.1", + "cspell-glob": "8.17.1", + "cspell-io": "8.17.1", "find-up-simple": "^1.0.0" }, "bin": { @@ -3745,13 +3644,12 @@ } }, "node_modules/cspell-glob": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/cspell-glob/-/cspell-glob-8.16.0.tgz", - "integrity": "sha512-xJSXRHwfENCNFmjpVSEucXY8E3BrpSCA+TukmOYtLyaMKtn6EAwoCpEU7Oj2tZOjdivprPmQ74k4Dqb1RHjIVQ==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/cspell-glob/-/cspell-glob-8.17.1.tgz", + "integrity": "sha512-cUwM5auSt0RvLX7UkP2GEArJRWc85l51B1voArl+3ZIKeMZwcJpJgN3qvImtF8yRTZwYeYCs1sgsihb179q+mg==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/url": "8.16.0", + "@cspell/url": "8.17.1", "micromatch": "^4.0.8" }, "engines": { @@ -3759,14 +3657,13 @@ } }, "node_modules/cspell-grammar": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/cspell-grammar/-/cspell-grammar-8.16.0.tgz", - "integrity": "sha512-vvbJEkBqXocGH/H975RtkfMzVpNxNGMd0JCDd+NjbpeRyZceuChFw5Tie7kHteFY29SwZovub+Am3F4H1kmf9A==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/cspell-grammar/-/cspell-grammar-8.17.1.tgz", + "integrity": "sha512-H5tLcBuW7aUj9L0rR+FSbnWPEsWb8lWppHVidtqw9Ll1CUHWOZC9HTB2RdrhJZrsz/8DJbM2yNbok0Xt0VAfdw==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/cspell-pipe": "8.16.0", - "@cspell/cspell-types": "8.16.0" + "@cspell/cspell-pipe": "8.17.1", + "@cspell/cspell-types": "8.17.1" }, "bin": { "cspell-grammar": "bin.mjs" @@ -3776,42 +3673,40 @@ } }, "node_modules/cspell-io": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/cspell-io/-/cspell-io-8.16.0.tgz", - "integrity": "sha512-WIK5uhPMjGsTAzm2/fGRbIdr7zWsMVG1fn8wNJYUiYELuyvzvLelfI1VG6szaFCGYqd6Uvgb/fS0uNbwGqCLAQ==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/cspell-io/-/cspell-io-8.17.1.tgz", + "integrity": "sha512-liIOsblt7oVItifzRAbuxiYrwlgw1VOqKppMxVKtYoAn2VUuuEpjCj6jLWpoTqSszR/38o7ChsHY1LHakhJZmw==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/cspell-service-bus": "8.16.0", - "@cspell/url": "8.16.0" + "@cspell/cspell-service-bus": "8.17.1", + "@cspell/url": "8.17.1" }, "engines": { "node": ">=18" } }, "node_modules/cspell-lib": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/cspell-lib/-/cspell-lib-8.16.0.tgz", - "integrity": "sha512-fU8CfECyuhT12COIi4ViQu2bTkdqaa+05YSd2ZV8k8NA7lapPaMFnlooxdfcwwgZJfHeMhRVMzvQF1OhWmwGfA==", - "dev": true, - "license": "MIT", - "dependencies": { - "@cspell/cspell-bundled-dicts": "8.16.0", - "@cspell/cspell-pipe": "8.16.0", - "@cspell/cspell-resolver": "8.16.0", - "@cspell/cspell-types": "8.16.0", - "@cspell/dynamic-import": "8.16.0", - "@cspell/filetypes": "8.16.0", - "@cspell/strong-weak-map": "8.16.0", - "@cspell/url": "8.16.0", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/cspell-lib/-/cspell-lib-8.17.1.tgz", + "integrity": "sha512-66n83Q7bK5tnvkDH7869/pBY/65AKmZVfCOAlsbhJn3YMDbNHFCHR0d1oNMlqG+n65Aco89VGwYfXxImZY+/mA==", + "dev": true, + "dependencies": { + "@cspell/cspell-bundled-dicts": "8.17.1", + "@cspell/cspell-pipe": "8.17.1", + "@cspell/cspell-resolver": "8.17.1", + "@cspell/cspell-types": "8.17.1", + "@cspell/dynamic-import": "8.17.1", + "@cspell/filetypes": "8.17.1", + "@cspell/strong-weak-map": "8.17.1", + "@cspell/url": "8.17.1", "clear-module": "^4.1.2", "comment-json": "^4.2.5", - "cspell-config-lib": "8.16.0", - "cspell-dictionary": "8.16.0", - "cspell-glob": "8.16.0", - "cspell-grammar": "8.16.0", - "cspell-io": "8.16.0", - "cspell-trie-lib": "8.16.0", + "cspell-config-lib": "8.17.1", + "cspell-dictionary": "8.17.1", + "cspell-glob": "8.17.1", + "cspell-grammar": "8.17.1", + "cspell-io": "8.17.1", + "cspell-trie-lib": "8.17.1", "env-paths": "^3.0.0", "fast-equals": "^5.0.1", "gensequence": "^7.0.0", @@ -3826,14 +3721,13 @@ } }, "node_modules/cspell-trie-lib": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/cspell-trie-lib/-/cspell-trie-lib-8.16.0.tgz", - "integrity": "sha512-Io1qqI0r4U9ewAWBLClFBBlxLeAoIi15PUGJi4Za1xrlgQJwRE8PMNIJNHKmPEIp78Iute3o/JyC2OfWlxl4Sw==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/cspell-trie-lib/-/cspell-trie-lib-8.17.1.tgz", + "integrity": "sha512-13WNa5s75VwOjlGzWprmfNbBFIfXyA7tYYrbV+LugKkznyNZJeJPojHouEudcLq3SYb2Q6tJ7qyWcuT5bR9qPA==", "dev": true, - "license": "MIT", "dependencies": { - "@cspell/cspell-pipe": "8.16.0", - "@cspell/cspell-types": "8.16.0", + "@cspell/cspell-pipe": "8.17.1", + "@cspell/cspell-types": "8.17.1", "gensequence": "^7.0.0" }, "engines": { @@ -3991,7 +3885,6 @@ "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-6.1.0.tgz", "integrity": "sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==", "dev": true, - "license": "MIT", "engines": { "node": ">=8" } @@ -4041,7 +3934,6 @@ "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", "dev": true, - "license": "MIT", "dependencies": { "path-type": "^4.0.0" }, @@ -4188,7 +4080,6 @@ "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-3.0.0.tgz", "integrity": "sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A==", "dev": true, - "license": "MIT", "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" }, @@ -4333,8 +4224,7 @@ "version": "0.1.7", "resolved": "https://registry.npmjs.org/extendable-error/-/extendable-error-0.1.7.tgz", "integrity": "sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/external-editor": { "version": "3.1.0", @@ -4355,7 +4245,6 @@ "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.0.1.tgz", "integrity": "sha512-WF1Wi8PwwSY7/6Kx0vKXtw8RwuSGoM1bvDaJbu7MxDlR1vovZjIAKrnzyrThgAjm6JDTu0fVgWXDlMGspodfoQ==", "dev": true, - "license": "MIT", "engines": { "node": ">=6.0.0" } @@ -4365,7 +4254,6 @@ "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz", "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==", "dev": true, - "license": "MIT", "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", @@ -4384,11 +4272,10 @@ "dev": true }, "node_modules/fastq": { - "version": "1.17.1", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz", - "integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==", + "version": "1.18.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.18.0.tgz", + "integrity": "sha512-QKHXPW0hD8g4UET03SdOdunzSouc9N4AuHdsX8XNcTsuz+yYFILVNIX4l9yHABMhiEI9Db0JTTIpu0wB+Y1QQw==", "dev": true, - "license": "ISC", "dependencies": { "reusify": "^1.0.4" } @@ -4474,7 +4361,6 @@ "resolved": "https://registry.npmjs.org/find-up-simple/-/find-up-simple-1.0.0.tgz", "integrity": "sha512-q7Us7kcjj2VMePAa02hDAF6d+MzsdsAWEwYyOpwUtlerRBkOEPBCRZrAV4XfcSN8fHAgaD0hP7miwoay6DCprw==", "dev": true, - "license": "MIT", "engines": { "node": ">=18" }, @@ -4577,7 +4463,6 @@ "resolved": "https://registry.npmjs.org/gensequence/-/gensequence-7.0.0.tgz", "integrity": "sha512-47Frx13aZh01afHJTB3zTtKIlFI6vWY+MYCN9Qpew6i52rfKjnhCF/l1YlC8UmEMvvntZZ6z4PiCcmyuedR2aQ==", "dev": true, - "license": "MIT", "engines": { "node": ">=18" } @@ -4708,7 +4593,6 @@ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", "dev": true, - "license": "ISC", "dependencies": { "is-glob": "^4.0.1" }, @@ -4721,7 +4605,6 @@ "resolved": "https://registry.npmjs.org/global-directory/-/global-directory-4.0.1.tgz", "integrity": "sha512-wHTUcDUoZ1H5/0iVqEudYW4/kAlN5cZ3j/bXn0Dpbizl9iaUVeWSHqiOjsgk6OW2bkLclbBjzewBz6weQ1zA2Q==", "dev": true, - "license": "MIT", "dependencies": { "ini": "4.1.1" }, @@ -4746,7 +4629,6 @@ "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", "dev": true, - "license": "MIT", "dependencies": { "array-union": "^2.1.0", "dir-glob": "^3.0.1", @@ -4782,7 +4664,6 @@ "resolved": "https://registry.npmjs.org/has-own-prop/-/has-own-prop-2.0.0.tgz", "integrity": "sha512-Pq0h+hvsVm6dDEa8x82GnLSYHOzNDt7f0ddFa3FqcQlgzEiptPqL+XrOJNavjOzSYiYWIrgeVYYgGlLmnxwilQ==", "dev": true, - "license": "MIT", "engines": { "node": ">=8" } @@ -4891,7 +4772,6 @@ "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", "dev": true, - "license": "MIT", "engines": { "node": ">= 4" } @@ -4901,7 +4781,6 @@ "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", "dev": true, - "license": "MIT", "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" @@ -4918,7 +4797,6 @@ "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", "dev": true, - "license": "MIT", "dependencies": { "callsites": "^3.0.0" }, @@ -4931,7 +4809,6 @@ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", "dev": true, - "license": "MIT", "engines": { "node": ">=4" } @@ -4960,7 +4837,6 @@ "resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-4.1.0.tgz", "integrity": "sha512-I6fiaX09Xivtk+THaMfAwnA3MVA5Big1WHF1Dfx9hFuvNIWpXnorlkzhcQf6ehrqQiiZECRt1poOAkPmer3ruw==", "dev": true, - "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -5054,7 +4930,6 @@ "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", "dev": true, - "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -5082,7 +4957,6 @@ "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", "dev": true, - "license": "MIT", "dependencies": { "is-extglob": "^2.1.1" }, @@ -5131,7 +5005,6 @@ "resolved": "https://registry.npmjs.org/is-subdir/-/is-subdir-1.2.0.tgz", "integrity": "sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==", "dev": true, - "license": "MIT", "dependencies": { "better-path-resolve": "1.0.0" }, @@ -5144,7 +5017,6 @@ "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", "dev": true, - "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -7136,8 +7008,7 @@ "version": "4.4.0", "resolved": "https://registry.npmjs.org/lodash.startcase/-/lodash.startcase-4.4.0.tgz", "integrity": "sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/longest-streak": { "version": "3.1.0", @@ -7470,7 +7341,6 @@ "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", "dev": true, - "license": "MIT", "engines": { "node": ">= 8" } @@ -8135,15 +8005,13 @@ "version": "0.5.0", "resolved": "https://registry.npmjs.org/outdent/-/outdent-0.5.0.tgz", "integrity": "sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/p-filter": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/p-filter/-/p-filter-2.1.0.tgz", "integrity": "sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==", "dev": true, - "license": "MIT", "dependencies": { "p-map": "^2.0.0" }, @@ -8183,7 +8051,6 @@ "resolved": "https://registry.npmjs.org/p-map/-/p-map-2.1.0.tgz", "integrity": "sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==", "dev": true, - "license": "MIT", "engines": { "node": ">=6" } @@ -8246,7 +8113,6 @@ "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-2.0.0.tgz", "integrity": "sha512-uo0Z9JJeWzv8BG+tRcapBKNJ0dro9cLyczGzulS6EfeyAdeC9sbojtW6XwvYxJkEne9En+J2XEl4zyglVeIwFg==", "dev": true, - "license": "MIT", "dependencies": { "callsites": "^3.1.0" }, @@ -8360,7 +8226,6 @@ "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", "dev": true, - "license": "MIT", "engines": { "node": ">=8" } @@ -8388,7 +8253,6 @@ "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", "dev": true, - "license": "MIT", "engines": { "node": ">=6" } @@ -8415,11 +8279,10 @@ } }, "node_modules/prettier": { - "version": "3.4.0", - "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.4.0.tgz", - "integrity": "sha512-/OXNZcLyWkfo13ofOW5M7SLh+k5pnIs07owXK2teFpnfaOEcycnSy7HQxldaVX1ZP/7Q8oO1eDuQJNwbomQq5Q==", + "version": "3.4.2", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.4.2.tgz", + "integrity": "sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ==", "dev": true, - "license": "MIT", "bin": { "prettier": "bin/prettier.cjs" }, @@ -8584,8 +8447,7 @@ "type": "consulting", "url": "https://feross.org/support" } - ], - "license": "MIT" + ] }, "node_modules/react-is": { "version": "18.2.0", @@ -8598,7 +8460,6 @@ "resolved": "https://registry.npmjs.org/read-yaml-file/-/read-yaml-file-1.1.0.tgz", "integrity": "sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==", "dev": true, - "license": "MIT", "dependencies": { "graceful-fs": "^4.1.5", "js-yaml": "^3.6.1", @@ -8614,7 +8475,6 @@ "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", "dev": true, - "license": "MIT", "engines": { "node": ">=4" } @@ -8623,8 +8483,7 @@ "version": "0.14.1", "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz", "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/remark-parse": { "version": "11.0.0", @@ -8662,7 +8521,6 @@ "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", "integrity": "sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==", "dev": true, - "license": "MIT", "engines": { "node": ">=0.10" } @@ -8728,7 +8586,6 @@ "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", "dev": true, - "license": "MIT", "engines": { "iojs": ">=1.0.0", "node": ">=0.10.0" @@ -8768,7 +8625,6 @@ "url": "https://feross.org/support" } ], - "license": "MIT", "dependencies": { "queue-microtask": "^1.2.2" } @@ -8929,7 +8785,6 @@ "resolved": "https://registry.npmjs.org/spawndamnit/-/spawndamnit-3.0.1.tgz", "integrity": "sha512-MmnduQUuHCoFckZoWnXsTg7JaiLBJrKFj9UI2MbRPGaJeVpsLcVBu6P/IGZovziM/YBsellCmsprgNA+w0CzVg==", "dev": true, - "license": "SEE LICENSE IN LICENSE", "dependencies": { "cross-spawn": "^7.0.5", "signal-exit": "^4.0.1" @@ -8940,7 +8795,6 @@ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", "dev": true, - "license": "ISC", "engines": { "node": ">=14" }, @@ -9586,15 +9440,13 @@ "version": "1.0.12", "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.12.tgz", "integrity": "sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/vscode-uri": { "version": "3.0.8", "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.0.8.tgz", "integrity": "sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==", - "dev": true, - "license": "MIT" + "dev": true }, "node_modules/walker": { "version": "1.0.8", @@ -9748,7 +9600,6 @@ "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-5.1.0.tgz", "integrity": "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ==", "dev": true, - "license": "MIT", "engines": { "node": ">=12" }, @@ -9772,11 +9623,10 @@ "dev": true }, "node_modules/yaml": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.6.1.tgz", - "integrity": "sha512-7r0XPzioN/Q9kXBro/XPnA6kznR73DHq+GXh5ON7ZozRO6aMjbmiBuKste2wslTFkC5d1dw0GooOCepZXJ2SAg==", + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.7.0.tgz", + "integrity": "sha512-+hSoy/QHluxmC9kCIJyL/uyFmLmc+e5CFR5Wa+bpIhIj85LVb9ZH2nVnqrHoSvKogwODv0ClqZkmiSSaIH5LTA==", "dev": true, - "license": "ISC", "bin": { "yaml": "bin.mjs" }, From 3936e23789be31f05ca2a9ad7b389d6a17b9d224 Mon Sep 17 00:00:00 2001 From: Omar Tawfik <15987992+OmarTawfik@users.noreply.github.com> Date: Wed, 1 Jan 2025 18:35:18 -0800 Subject: [PATCH 4/4] Use database of partial paths to speed up bindings resolution (#1204) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Rebasing #1198 on latest after #1195 was merged. --------- Co-authored-by: Gustavo Giráldez --- Cargo.lock | 10 +- Cargo.toml | 2 +- .../crate/src/extensions/bindings/mod.rs | 4 +- .../cargo/crate/src/runtime/bindings/mod.rs | 9 +- .../crate/src/runtime/compilation/unit.rs | 6 +- .../cargo/crate/src/runtime/cst/mod.rs | 2 +- .../wasm/src/runtime/wrappers/bindings/mod.rs | 58 +- .../bindings/generated/public_api.txt | 92 +- .../src/builder/{ => loader}/cancellation.rs | 0 .../src/builder/{ => loader}/functions.rs | 3 +- .../bindings/src/builder/loader/mod.rs | 988 +++++++++++++++ crates/metaslang/bindings/src/builder/mod.rs | 1096 +++-------------- .../bindings/src/builder/resolver.rs | 300 +++++ .../bindings/src/graph/definition.rs | 96 ++ .../{location/mod.rs => graph/location.rs} | 0 crates/metaslang/bindings/src/graph/mod.rs | 159 +++ .../metaslang/bindings/src/graph/reference.rs | 81 ++ crates/metaslang/bindings/src/lib.rs | 474 +------ crates/metaslang/bindings/src/resolver/mod.rs | 212 ---- crates/metaslang/cst/generated/public_api.txt | 34 +- crates/metaslang/cst/src/kinds.rs | 28 + crates/metaslang/cst/src/nodes.rs | 30 +- crates/metaslang/cst/src/query/engine.rs | 3 +- crates/metaslang/cst/src/query/model.rs | 3 +- crates/metaslang/cst/src/query/parser.rs | 3 +- .../inputs/language/bindings/rules.msgb | 5 + .../cargo/crate/generated/public_api.txt | 14 +- .../crate/src/extensions/bindings/mod.rs | 6 +- .../bindings/generated/binding_rules.rs | 5 + .../cargo/crate/src/generated/bindings/mod.rs | 9 +- .../crate/src/generated/compilation/unit.rs | 6 +- .../cargo/crate/src/generated/cst/mod.rs | 2 +- .../tests/src/bindings_output/renderer.rs | 48 +- .../cargo/tests/src/bindings_output/runner.rs | 7 +- .../src/generated/wrappers/bindings/mod.rs | 58 +- .../solidity/testing/perf/benches/iai/main.rs | 20 +- crates/solidity/testing/perf/src/lib.rs | 13 +- .../testing/perf/src/tests/bindings_build.rs | 40 + .../perf/src/tests/bindings_resolve.rs | 61 + .../testing/perf/src/tests/definitions.rs | 43 - .../testing/perf/src/tests/init_bindings.rs | 24 - crates/solidity/testing/perf/src/tests/mod.rs | 5 +- .../solidity/testing/perf/src/tests/parser.rs | 1 + .../testing/perf/src/tests/references.rs | 32 - .../solidity/testing/sanctuary/src/tests.rs | 49 +- .../crate/src/extensions/bindings/mod.rs | 4 +- .../cargo/crate/src/generated/bindings/mod.rs | 9 +- .../crate/src/generated/compilation/unit.rs | 6 +- .../cargo/crate/src/generated/cst/mod.rs | 2 +- .../src/generated/wrappers/bindings/mod.rs | 58 +- 50 files changed, 2138 insertions(+), 2082 deletions(-) rename crates/metaslang/bindings/src/builder/{ => loader}/cancellation.rs (100%) rename crates/metaslang/bindings/src/builder/{ => loader}/functions.rs (98%) create mode 100644 crates/metaslang/bindings/src/builder/loader/mod.rs create mode 100644 crates/metaslang/bindings/src/builder/resolver.rs create mode 100644 crates/metaslang/bindings/src/graph/definition.rs rename crates/metaslang/bindings/src/{location/mod.rs => graph/location.rs} (100%) create mode 100644 crates/metaslang/bindings/src/graph/mod.rs create mode 100644 crates/metaslang/bindings/src/graph/reference.rs delete mode 100644 crates/metaslang/bindings/src/resolver/mod.rs create mode 100644 crates/solidity/testing/perf/src/tests/bindings_build.rs create mode 100644 crates/solidity/testing/perf/src/tests/bindings_resolve.rs delete mode 100644 crates/solidity/testing/perf/src/tests/definitions.rs delete mode 100644 crates/solidity/testing/perf/src/tests/init_bindings.rs delete mode 100644 crates/solidity/testing/perf/src/tests/references.rs diff --git a/Cargo.lock b/Cargo.lock index 528900d499..6284efc61a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1506,9 +1506,8 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" [[package]] name = "lsp-positions" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa61ce94f83d24eba829bbba054b40e9996d8531c87670799fd0c43dea97be37" +version = "0.3.4" +source = "git+https://github.com/NomicFoundation/stack-graphs?branch=nomic#9631ed9c7de4443525491745d46557dc16a7355c" dependencies = [ "memchr", "unicode-segmentation", @@ -2545,9 +2544,8 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" [[package]] name = "stack-graphs" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af63a628b6666b3ce870cac60623d71d1575a9ccc5b2f0a2f83143c3e7da9a3a" +version = "0.14.1" +source = "git+https://github.com/NomicFoundation/stack-graphs?branch=nomic#9631ed9c7de4443525491745d46557dc16a7355c" dependencies = [ "bitvec", "controlled-option", diff --git a/Cargo.toml b/Cargo.toml index 21308200f8..dd157f1f16 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -130,7 +130,7 @@ serde = { version = "1.0.217", features = ["derive", "rc"] } serde_json = { version = "1.0.134", features = ["preserve_order"] } similar-asserts = { version = "1.6.0" } smallvec = { version = "1.7.0", features = ["union"] } -stack-graphs = { version = "0.13.0" } +stack-graphs = { git = "https://github.com/NomicFoundation/stack-graphs", branch = "nomic" } string-interner = { version = "0.17.0", features = [ "std", "inline-more", diff --git a/crates/codegen/runtime/cargo/crate/src/extensions/bindings/mod.rs b/crates/codegen/runtime/cargo/crate/src/extensions/bindings/mod.rs index eee8b7880f..c3f95c7400 100644 --- a/crates/codegen/runtime/cargo/crate/src/extensions/bindings/mod.rs +++ b/crates/codegen/runtime/cargo/crate/src/extensions/bindings/mod.rs @@ -1,11 +1,11 @@ use semver::Version; -use crate::bindings::BindingGraph; +use crate::bindings::BindingGraphBuilder; use crate::parser::ParserInitializationError; #[allow(clippy::needless_pass_by_value)] pub fn add_built_ins( - _binding_graph: &mut BindingGraph, + _binding_graph_builder: &mut BindingGraphBuilder, _version: Version, ) -> Result<(), ParserInitializationError> { unreachable!("Built-ins are Solidity-specific") diff --git a/crates/codegen/runtime/cargo/crate/src/runtime/bindings/mod.rs b/crates/codegen/runtime/cargo/crate/src/runtime/bindings/mod.rs index 4766b80e6c..052c6ba4f2 100644 --- a/crates/codegen/runtime/cargo/crate/src/runtime/bindings/mod.rs +++ b/crates/codegen/runtime/cargo/crate/src/runtime/bindings/mod.rs @@ -10,9 +10,10 @@ use semver::Version; use crate::cst::KindTypes; +pub type BindingGraphBuilder = metaslang_bindings::BindingGraphBuilder; pub type BindingGraph = metaslang_bindings::BindingGraph; -pub type Definition<'a> = metaslang_bindings::Definition<'a, KindTypes>; -pub type Reference<'a> = metaslang_bindings::Reference<'a, KindTypes>; +pub type Definition = metaslang_bindings::Definition; +pub type Reference = metaslang_bindings::Reference; pub type BindingLocation = metaslang_bindings::BindingLocation; pub type UserFileLocation = metaslang_bindings::UserFileLocation; @@ -29,8 +30,8 @@ pub enum BindingGraphInitializationError { pub fn create_with_resolver( version: Version, resolver: Rc>, -) -> Result { - let mut binding_graph = BindingGraph::create( +) -> Result { + let mut binding_graph = BindingGraphBuilder::create( version.clone(), binding_rules::BINDING_RULES_SOURCE, resolver, diff --git a/crates/codegen/runtime/cargo/crate/src/runtime/compilation/unit.rs b/crates/codegen/runtime/cargo/crate/src/runtime/compilation/unit.rs index aea2d3cd9c..e909b5882d 100644 --- a/crates/codegen/runtime/cargo/crate/src/runtime/compilation/unit.rs +++ b/crates/codegen/runtime/cargo/crate/src/runtime/compilation/unit.rs @@ -43,14 +43,14 @@ impl CompilationUnit { files: self.files.clone(), }; - let mut binding_graph = + let mut builder = create_with_resolver(self.language_version.clone(), Rc::new(resolver))?; for (id, file) in &self.files { - binding_graph.add_user_file(id, file.create_tree_cursor()); + builder.add_user_file(id, file.create_tree_cursor()); } - Ok(Rc::new(binding_graph)) + Ok(builder.build()) }) } } diff --git a/crates/codegen/runtime/cargo/crate/src/runtime/cst/mod.rs b/crates/codegen/runtime/cargo/crate/src/runtime/cst/mod.rs index 53885c6a25..7aa60861d2 100644 --- a/crates/codegen/runtime/cargo/crate/src/runtime/cst/mod.rs +++ b/crates/codegen/runtime/cargo/crate/src/runtime/cst/mod.rs @@ -10,7 +10,7 @@ mod terminal_kind; pub use edge_label::EdgeLabel; pub(crate) use lexical_context::{IsLexicalContext, LexicalContext, LexicalContextType}; pub use metaslang_cst::kinds::{ - EdgeLabelExtensions, NonterminalKindExtensions, TerminalKindExtensions, + EdgeLabelExtensions, NodeKind, NonterminalKindExtensions, TerminalKindExtensions, }; pub use nonterminal_kind::NonterminalKind; pub use terminal_kind::TerminalKind; diff --git a/crates/codegen/runtime/cargo/wasm/src/runtime/wrappers/bindings/mod.rs b/crates/codegen/runtime/cargo/wasm/src/runtime/wrappers/bindings/mod.rs index c093fb0b7c..7d2d23d710 100644 --- a/crates/codegen/runtime/cargo/wasm/src/runtime/wrappers/bindings/mod.rs +++ b/crates/codegen/runtime/cargo/wasm/src/runtime/wrappers/bindings/mod.rs @@ -12,52 +12,8 @@ mod ffi { mod rust { pub use crate::rust_crate::bindings::{ - BindingGraph, BindingLocation, BuiltInLocation, UserFileLocation, + BindingGraph, BindingLocation, BuiltInLocation, Definition, Reference, UserFileLocation, }; - - /// TODO: This is a work-around for the fact that `metaslang_bindings` internals (handles, locators, etc...) are exposed. - /// We should clean this when we finally publish `__experimental_bindings_api`. - /// That means removing the types below, and using the original types instead. - #[derive(Debug, Clone)] - pub struct Definition { - pub id: usize, - pub name_location: BindingLocation, - pub definiens_location: BindingLocation, - } - - impl From> for Definition { - fn from(definition: crate::rust_crate::bindings::Definition<'_>) -> Self { - Self { - id: definition.id(), - name_location: definition.name_location(), - definiens_location: definition.definiens_location(), - } - } - } - - /// TODO: This is a work-around for the fact that `metaslang_bindings` internals (handles, locators, etc...) are exposed. - /// We should clean this when we finally publish `__experimental_bindings_api`. - /// That means removing the types below, and using the original types instead. - #[derive(Debug, Clone)] - pub struct Reference { - pub id: usize, - pub location: BindingLocation, - pub definitions: Vec, - } - - impl From> for Reference { - fn from(reference: crate::rust_crate::bindings::Reference<'_>) -> Self { - Self { - id: reference.id(), - location: reference.location(), - definitions: reference - .definitions() - .into_iter() - .map(Into::into) - .collect(), - } - } - } } impl ffi::Guest for crate::wasm_crate::World { @@ -100,15 +56,15 @@ define_rc_wrapper! { BindingGraph { define_wrapper! { Definition { fn id(&self) -> u32 { - self._borrow_ffi().id.try_into().unwrap() + self._borrow_ffi().id().try_into().unwrap() } fn name_location(&self) -> ffi::BindingLocation { - self._borrow_ffi().name_location.clone()._into_ffi() + self._borrow_ffi().name_location()._into_ffi() } fn definiens_location(&self) -> ffi::BindingLocation { - self._borrow_ffi().definiens_location.clone()._into_ffi() + self._borrow_ffi().definiens_location()._into_ffi() } } } @@ -120,15 +76,15 @@ define_wrapper! { Definition { define_wrapper! { Reference { fn id(&self) -> u32 { - self._borrow_ffi().id.try_into().unwrap() + self._borrow_ffi().id().try_into().unwrap() } fn location(&self) -> ffi::BindingLocation { - self._borrow_ffi().location.clone()._into_ffi() + self._borrow_ffi().location().clone()._into_ffi() } fn definitions(&self) -> Vec { - self._borrow_ffi().definitions.iter().cloned().map(IntoFFI::_into_ffi).collect() + self._borrow_ffi().definitions().iter().cloned().map(IntoFFI::_into_ffi).collect() } } } diff --git a/crates/metaslang/bindings/generated/public_api.txt b/crates/metaslang/bindings/generated/public_api.txt index e4b11e5bec..a029a0307a 100644 --- a/crates/metaslang/bindings/generated/public_api.txt +++ b/crates/metaslang/bindings/generated/public_api.txt @@ -11,64 +11,54 @@ impl core::c pub fn metaslang_bindings::BindingLocation::clone(&self) -> metaslang_bindings::BindingLocation impl core::fmt::Debug for metaslang_bindings::BindingLocation pub fn metaslang_bindings::BindingLocation::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -pub enum metaslang_bindings::FileDescriptor -pub metaslang_bindings::FileDescriptor::System(alloc::string::String) -pub metaslang_bindings::FileDescriptor::User(alloc::string::String) -impl metaslang_bindings::FileDescriptor -pub fn metaslang_bindings::FileDescriptor::get_path(&self) -> &str -pub fn metaslang_bindings::FileDescriptor::is_system(&self) -> bool -pub fn metaslang_bindings::FileDescriptor::is_user(&self) -> bool -pub fn metaslang_bindings::FileDescriptor::is_user_path(&self, path: &str) -> bool -pub enum metaslang_bindings::ResolutionError<'a, KT: metaslang_cst::kinds::KindTypes + 'static> -pub metaslang_bindings::ResolutionError::AmbiguousDefinitions(alloc::vec::Vec>) -pub metaslang_bindings::ResolutionError::Unresolved pub struct metaslang_bindings::BindingGraph impl metaslang_bindings::BindingGraph -pub fn metaslang_bindings::BindingGraph::add_system_file(&mut self, file_path: &str, tree_cursor: metaslang_cst::cursor::Cursor) -pub fn metaslang_bindings::BindingGraph::add_user_file(&mut self, file_path: &str, tree_cursor: metaslang_cst::cursor::Cursor) -pub fn metaslang_bindings::BindingGraph::add_user_file_returning_graph(&mut self, file_path: &str, tree_cursor: metaslang_cst::cursor::Cursor) -> metaslang_graph_builder::graph::Graph -pub fn metaslang_bindings::BindingGraph::all_definitions(&self) -> impl core::iter::traits::iterator::Iterator> + '_ -pub fn metaslang_bindings::BindingGraph::all_references(&self) -> impl core::iter::traits::iterator::Iterator> + '_ -pub fn metaslang_bindings::BindingGraph::create(version: semver::Version, binding_rules: &str, path_resolver: alloc::rc::Rc>) -> Self -pub fn metaslang_bindings::BindingGraph::definition_at(&self, cursor: &metaslang_cst::cursor::Cursor) -> core::option::Option> -pub fn metaslang_bindings::BindingGraph::reference_at(&self, cursor: &metaslang_cst::cursor::Cursor) -> core::option::Option> +pub fn metaslang_bindings::BindingGraph::all_definitions(self: &alloc::rc::Rc) -> impl core::iter::traits::iterator::Iterator> + '_ +pub fn metaslang_bindings::BindingGraph::all_references(self: &alloc::rc::Rc) -> impl core::iter::traits::iterator::Iterator> + '_ +pub fn metaslang_bindings::BindingGraph::definition_at(self: &alloc::rc::Rc, cursor: &metaslang_cst::cursor::Cursor) -> core::option::Option> +pub fn metaslang_bindings::BindingGraph::reference_at(self: &alloc::rc::Rc, cursor: &metaslang_cst::cursor::Cursor) -> core::option::Option> +pub struct metaslang_bindings::BindingGraphBuilder +impl metaslang_bindings::BindingGraphBuilder +pub fn metaslang_bindings::BindingGraphBuilder::add_system_file(&mut self, file_path: &str, tree_cursor: metaslang_cst::cursor::Cursor) +pub fn metaslang_bindings::BindingGraphBuilder::add_user_file(&mut self, file_path: &str, tree_cursor: metaslang_cst::cursor::Cursor) +pub fn metaslang_bindings::BindingGraphBuilder::add_user_file_returning_graph(&mut self, file_path: &str, tree_cursor: metaslang_cst::cursor::Cursor) -> metaslang_graph_builder::graph::Graph +pub fn metaslang_bindings::BindingGraphBuilder::build(self) -> alloc::rc::Rc> +pub fn metaslang_bindings::BindingGraphBuilder::create(version: semver::Version, binding_rules: &str, path_resolver: alloc::rc::Rc>) -> Self pub struct metaslang_bindings::BuiltInLocation impl core::clone::Clone for metaslang_bindings::BuiltInLocation pub fn metaslang_bindings::BuiltInLocation::clone(&self) -> metaslang_bindings::BuiltInLocation impl core::fmt::Debug for metaslang_bindings::BuiltInLocation pub fn metaslang_bindings::BuiltInLocation::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -pub struct metaslang_bindings::Definition<'a, KT: metaslang_cst::kinds::KindTypes + 'static> -impl<'a, KT: metaslang_cst::kinds::KindTypes + 'static> metaslang_bindings::Definition<'a, KT> -pub fn metaslang_bindings::Definition<'a, KT>::definiens_location(&self) -> metaslang_bindings::BindingLocation -pub fn metaslang_bindings::Definition<'a, KT>::get_cursor(&self) -> &metaslang_cst::cursor::Cursor -pub fn metaslang_bindings::Definition<'a, KT>::get_definiens_cursor(&self) -> &metaslang_cst::cursor::Cursor -pub fn metaslang_bindings::Definition<'a, KT>::get_file(&self) -> metaslang_bindings::FileDescriptor -pub fn metaslang_bindings::Definition<'a, KT>::id(&self) -> usize -pub fn metaslang_bindings::Definition<'a, KT>::name_location(&self) -> metaslang_bindings::BindingLocation -impl<'a, KT: core::clone::Clone + metaslang_cst::kinds::KindTypes + 'static> core::clone::Clone for metaslang_bindings::Definition<'a, KT> -pub fn metaslang_bindings::Definition<'a, KT>::clone(&self) -> metaslang_bindings::Definition<'a, KT> -impl core::cmp::Eq for metaslang_bindings::Definition<'_, KT> -impl core::cmp::PartialEq for metaslang_bindings::Definition<'_, KT> -pub fn metaslang_bindings::Definition<'_, KT>::eq(&self, other: &Self) -> bool -impl core::fmt::Debug for metaslang_bindings::Definition<'_, KT> -pub fn metaslang_bindings::Definition<'_, KT>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for metaslang_bindings::Definition<'_, KT> -pub fn metaslang_bindings::Definition<'_, KT>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::hash::Hash for metaslang_bindings::Definition<'_, KT> -pub fn metaslang_bindings::Definition<'_, KT>::hash(&self, state: &mut H) -pub struct metaslang_bindings::Reference<'a, KT: metaslang_cst::kinds::KindTypes + 'static> -impl<'a, KT: metaslang_cst::kinds::KindTypes + 'static> metaslang_bindings::Reference<'a, KT> -pub fn metaslang_bindings::Reference<'a, KT>::definitions(&self) -> alloc::vec::Vec> -pub fn metaslang_bindings::Reference<'a, KT>::get_cursor(&self) -> &metaslang_cst::cursor::Cursor -pub fn metaslang_bindings::Reference<'a, KT>::get_file(&self) -> metaslang_bindings::FileDescriptor -pub fn metaslang_bindings::Reference<'a, KT>::id(&self) -> usize -pub fn metaslang_bindings::Reference<'a, KT>::location(&self) -> metaslang_bindings::BindingLocation -impl<'a, KT: core::clone::Clone + metaslang_cst::kinds::KindTypes + 'static> core::clone::Clone for metaslang_bindings::Reference<'a, KT> -pub fn metaslang_bindings::Reference<'a, KT>::clone(&self) -> metaslang_bindings::Reference<'a, KT> -impl core::cmp::PartialEq for metaslang_bindings::Reference<'_, KT> -pub fn metaslang_bindings::Reference<'_, KT>::eq(&self, other: &Self) -> bool -impl core::fmt::Display for metaslang_bindings::Reference<'_, KT> -pub fn metaslang_bindings::Reference<'_, KT>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct metaslang_bindings::Definition +impl metaslang_bindings::Definition +pub fn metaslang_bindings::Definition::definiens_location(&self) -> metaslang_bindings::BindingLocation +pub fn metaslang_bindings::Definition::get_cursor(&self) -> &metaslang_cst::cursor::Cursor +pub fn metaslang_bindings::Definition::get_definiens_cursor(&self) -> &metaslang_cst::cursor::Cursor +pub fn metaslang_bindings::Definition::get_file(&self) -> FileDescriptor +pub fn metaslang_bindings::Definition::id(&self) -> usize +pub fn metaslang_bindings::Definition::name_location(&self) -> metaslang_bindings::BindingLocation +impl core::clone::Clone for metaslang_bindings::Definition +pub fn metaslang_bindings::Definition::clone(&self) -> metaslang_bindings::Definition +impl core::cmp::Eq for metaslang_bindings::Definition +impl core::cmp::PartialEq for metaslang_bindings::Definition +pub fn metaslang_bindings::Definition::eq(&self, other: &Self) -> bool +impl core::fmt::Debug for metaslang_bindings::Definition +pub fn metaslang_bindings::Definition::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::fmt::Display for metaslang_bindings::Definition +pub fn metaslang_bindings::Definition::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct metaslang_bindings::Reference +impl metaslang_bindings::Reference +pub fn metaslang_bindings::Reference::definitions(&self) -> alloc::vec::Vec> +pub fn metaslang_bindings::Reference::get_cursor(&self) -> &metaslang_cst::cursor::Cursor +pub fn metaslang_bindings::Reference::get_file(&self) -> FileDescriptor +pub fn metaslang_bindings::Reference::id(&self) -> usize +pub fn metaslang_bindings::Reference::location(&self) -> metaslang_bindings::BindingLocation +impl core::clone::Clone for metaslang_bindings::Reference +pub fn metaslang_bindings::Reference::clone(&self) -> metaslang_bindings::Reference +impl core::cmp::PartialEq for metaslang_bindings::Reference +pub fn metaslang_bindings::Reference::eq(&self, other: &Self) -> bool +impl core::fmt::Display for metaslang_bindings::Reference +pub fn metaslang_bindings::Reference::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct metaslang_bindings::UserFileLocation impl metaslang_bindings::UserFileLocation pub fn metaslang_bindings::UserFileLocation::cursor(&self) -> &metaslang_cst::cursor::Cursor diff --git a/crates/metaslang/bindings/src/builder/cancellation.rs b/crates/metaslang/bindings/src/builder/loader/cancellation.rs similarity index 100% rename from crates/metaslang/bindings/src/builder/cancellation.rs rename to crates/metaslang/bindings/src/builder/loader/cancellation.rs diff --git a/crates/metaslang/bindings/src/builder/functions.rs b/crates/metaslang/bindings/src/builder/loader/functions.rs similarity index 98% rename from crates/metaslang/bindings/src/builder/functions.rs rename to crates/metaslang/bindings/src/builder/loader/functions.rs index 27ff5d9aa3..6219d7e2aa 100644 --- a/crates/metaslang/bindings/src/builder/functions.rs +++ b/crates/metaslang/bindings/src/builder/loader/functions.rs @@ -63,7 +63,8 @@ mod resolver { use metaslang_graph_builder::graph::{Graph, Value}; use metaslang_graph_builder::ExecutionError; - use crate::{FileDescriptor, PathResolver}; + use crate::builder::FileDescriptor; + use crate::PathResolver; pub fn add_functions( functions: &mut Functions, diff --git a/crates/metaslang/bindings/src/builder/loader/mod.rs b/crates/metaslang/bindings/src/builder/loader/mod.rs new file mode 100644 index 0000000000..56b679d0a6 --- /dev/null +++ b/crates/metaslang/bindings/src/builder/loader/mod.rs @@ -0,0 +1,988 @@ +// -*- coding: utf-8 -*- +// ------------------------------------------------------------------------------------------------ +// Copyright © 2021, stack-graphs authors. +// Copyright © 2024, slang authors. +// Licensed under MIT license +// Please see the LICENSE file in the root of this crate for license details. +// ------------------------------------------------------------------------------------------------ + +//! This module lets you construct [stack graphs][] using this crate's [graph construction DSL][]. +//! The graph DSL lets you construct arbitrary graph structures from the parsed syntax tree of a +//! source file. If you construct a graph using the vocabulary of attributes described below, then +//! the result of executing the graph DSL will be a valid stack graph, which we can then use for +//! name binding lookups. +//! +//! ## Prerequisites +//! +//! [stack graphs]: https://docs.rs/stack-graphs/*/ +//! [graph construction DSL]: https://docs.rs/metaslang_graph_builder/*/ +//! +//! To process a particular source language, you'll need to first get the CST from the source, using +//! the parser constructed from the language definition that uses the `metaslang_cst` crate. +//! +//! You will then need to create _stack graph construction rules_ for your language. These rules +//! are implemented using metaslang's [graph construction DSL][], which is based from tree-sitter's +//! graph construction DSL. They define the particular stack graph nodes and edges that should be +//! created for each part of the parsed syntax tree of a source file. +//! +//! ## Graph DSL vocabulary +//! +//! **Please note**: This documentation assumes you are already familiar with stack graphs, and how +//! to use different stack graph node types, and the connectivity between nodes, to implement the +//! name binding semantics of your language. We assume that you know what kind of stack graph you +//! want to produce; this documentation focuses only on the mechanics of _how_ to create that stack +//! graph content. +//! +//! As mentioned above, your stack graph construction rules should create stack graph nodes and +//! edges from the parsed content of a source file. You will use MSGB [stanzas][] to match on +//! different parts of the parsed syntax tree, and create stack graph content for each match. +//! +//! ### Creating stack graph nodes +//! +//! To create a stack graph node for each identifier in a Solidity file, you could use the following +//! MSGB stanza: +//! +//! ``` skip +//! [Identifier] { +//! node new_node +//! } +//! ``` +//! +//! (Here, `node` is a MSGB statement that creates a new node, and `new_node` is the name of a local +//! variable that the new node is assigned to, letting you refer to the new node in the rest of the +//! stanza.) +//! +//! [stanzas]: https://docs.rs/tree-sitter-graph/*/tree_sitter_graph/reference/index.html#high-level-structure +//! +//! By default, this new node will be a _scope node_. If you need to create a different kind of stack +//! graph node, set the `type` attribute on the new node: +//! +//! ``` skip +//! [Identifier] { +//! node new_node +//! attr (new_node) type = "push_symbol" +//! } +//! ``` +//! +//! The valid `type` values are: +//! +//! - `drop_scopes`: a _drop scopes_ node +//! - `pop_symbol`: a _pop symbol_ node +//! - `pop_scoped_symbol`: a _pop scoped symbol_ node +//! - `push_symbol`: a _push symbol_ node +//! - `push_scoped_symbol`: a _push scoped symbol_ node +//! - `scope`: a _scope_ node +//! +//! A node without an explicit `type` attribute is assumed to be of type `scope`. +//! +//! Certain node types — `pop_symbol`, `pop_scoped_symbol`, `push_symbol` and `push_scoped_symbol` — +//! also require you to provide a `symbol` attribute. Its value must be a string, but will typically +//! come from the content of a parsed syntax node using the [`source-text`][] function and a syntax +//! capture: +//! +//! [`source-text`]: https://docs.rs/tree-sitter-graph/*/tree_sitter_graph/reference/functions/index.html#source-text +//! +//! ``` skip +//! @id [Identifier] { +//! node new_node +//! attr (new_node) type = "push_symbol", symbol = (source-text @id) +//! } +//! ``` +//! +//! Node types `pop_symbol` and `pop_scoped_symbol` allow an optional `is_definition` attribute, +//! which marks that node as a proper definition. Node types `push_symbol` and `push_scoped_symbol` +//! allow an optional `is_reference` attribute, which marks the node as a proper reference. When +//! `is_definition` or `is_reference` are set, the `source_node` attribute is required. +//! +//! ``` skip +//! @id [Identifier] { +//! node new_node +//! attr (new_node) type = "push_symbol", symbol = (source-text @id), is_reference, source_node = @id +//! } +//! ``` +//! +//! A _push scoped symbol_ node requires a `scope` attribute. Its value must be a reference to an +//! `exported` node that you've already created. (This is the exported scope node that will be +//! pushed onto the scope stack.) For instance: +//! +//! ``` skip +//! @id [Identifier] { +//! node new_exported_scope_node +//! attr (new_exported_scope_node) is_exported +//! node new_push_scoped_symbol_node +//! attr (new_push_scoped_symbol_node) +//! type = "push_scoped_symbol", +//! symbol = (source-text @id), +//! scope = new_exported_scope_node +//! } +//! ``` +//! +//! Nodes of type `scope` allow an optional `is_exported` attribute, that is required to use the +//! scope in a `push_scoped_symbol` node. +//! +//! +//! ### Annotating nodes with location information +//! +//! You can annotate any stack graph node that you create with location information, identifying +//! the portion of the source file that the node "belongs to". This is _required_ for definition +//! and reference nodes, since the location information determines which parts of the source file +//! the user can _click on_, and the _destination_ of any code navigation queries the user makes. +//! To do this, add a `source_node` attribute, whose value is a syntax node capture: +//! +//! ``` skip +//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { +//! node def +//! attr (def) type = "pop_symbol", symbol = (source-text @id), source_node = @func, is_definition +//! } +//! ``` +//! +//! Note how in this example, we use a different syntax node for the _target_ of the definition +//! (the entirety of the function definition) and for the _name_ of the definition (the content of +//! the function's `name`). +//! +//! Adding the `empty_source_span` attribute will use an empty source span located at the start of +//! the span of the `source_node`. This can be useful when a proper reference or definition is +//! desired, and thus `source_node` is required, but the span of the available source node is too +//! large. For example, a module definition which is located at the start of the program, but does +//! span the whole program: +//! +//! ``` skip +//! @unit [SourceUnit] { +//! ; ... +//! node mod_def +//! attr mod_def type = "pop_symbol", symbol = mod_name, is_definition, source_node = @unit, empty_source_span +//! ; ... +//! } +//! ``` +//! +//! ### Annotating nodes with syntax type information +//! +//! You can annotate any stack graph node with information about its syntax type. To do this, add a +//! `syntax_type` attribute, whose value is a string indicating the syntax type. +//! +//! ``` skip +//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { +//! node def +//! ; ... +//! attr (def) syntax_type = "function" +//! } +//! ``` +//! +//! ### Annotating definitions with definiens information +//! +//! You cannot annotate definitions with a definiens, which is the thing the definition covers. For +//! example, for a function definition, the definiens would be the function body. To do this, add a +//! `definiens_node` attribute, whose value is a syntax node that spans the definiens. +//! +//! ``` skip +//! @func [FunctionDefinition [FunctionName @id [Identifier]] @body [FunctionBody]] { +//! node def +//! ; ... +//! attr (def) definiens_node = @body +//! } +//! ``` +//! +//! Definiens are optional and setting them to `#null` explicitly is allowed. +//! +//! ### Connecting stack graph nodes with edges +//! +//! To connect two stack graph nodes, use the `edge` statement to add an edge between them: +//! +//! ``` skip +//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { +//! node def +//! attr (def) type = "pop_symbol", symbol = (source-text @id), source_node = @func, is_definition +//! node body +//! edge def -> body +//! } +//! ``` +//! +//! To implement shadowing (which determines which definitions are selected when multiple are available), +//! you can add a `precedence` attribute to each edge to indicate which paths are prioritized: +//! +//! ``` skip +//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { +//! node def +//! attr (def) type = "pop_symbol", symbol = (source-text @id), source_node = @func, is_definition +//! node body +//! edge def -> body +//! attr (def -> body) precedence = 1 +//! } +//! ``` +//! +//! (If you don't specify a `precedence`, the default is 0.) +//! +//! ### Referring to the singleton nodes +//! +//! The _root node_ and _jump to scope node_ are singleton nodes that always exist for all stack +//! graphs. You can refer to them using the `ROOT_NODE` and `JUMP_TO_SCOPE_NODE` global variables: +//! +//! ``` skip +//! global ROOT_NODE +//! +//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { +//! node def +//! attr (def) type = "pop_symbol", symbol = (source-text @id), source_node = @func, is_definition +//! edge ROOT_NODE -> def +//! } +//! ``` +//! +//! ### Attaching debug information to nodes +//! +//! It is possible to attach extra information to nodes for debugging purposes. This is done by adding +//! `debug_*` attributes to nodes. Each attribute defines a debug entry, with the key derived from the +//! attribute name, and the value the string representation of the attribute value. For example, mark +//! a scope node with a kind as follows: +//! +//! ``` skip +//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { +//! ; ... +//! node param_scope +//! attr (param_scope) debug_kind = "param_scope" +//! ; ... +//! } +//! ``` +//! +//! ### Other node attributes introduced in Slang's usage of stack-graphs +//! +//! #### `parents` attribute +//! +//! Is used to convey semantic hierarchy. Can be applied to both definitions and +//! references. It's an optional, list of graph nodes attribute. +//! +//! For references it can indicate in which language context the reference +//! occurs (eg. in which method or class). For definitions it can indicate the +//! enclosing type of the definition, or parent classes in a class hierarchy. +//! The parent handles themselves can refer to definitions or references. In the +//! later case, generally speaking they will need to be resolved at resolution +//! time in order to be useful. +//! +//! #### `extension_hook`, `extension_scope` and `inherit_extensions` +//! +//! These attributes enable the bindings API to resolve extension methods by +//! injecting specific scopes at potentially unrelated (lexically speaking) +//! nodes in the stack graph. Availability and application of extension scopes +//! depend on the call site (ie. the reference node). Thus, the extension scope +//! to (potentially) apply when resolving a reference is computed by looking up +//! the `parents` of the reference and then querying those parent nodes for +//! their `extension_scope` (an optional scope node). Any extension providing +//! node can also have the `inherit_extensions` attribute (a boolean) which +//! indicates that the algorithm should recurse and resolve its parents to +//! further look for other extensions scopes. +//! +//! Finally, the attribute `extension_hook` defines where in the graph should +//! these extension scopes be injected. This is typically the root lexical +//! scope. This attribute applies to any scope node and is boolean. +//! + +mod cancellation; +mod functions; + +use std::collections::{HashMap, HashSet}; + +pub use cancellation::{CancellationFlag, NoCancellation}; +pub use functions::default_functions; +use metaslang_cst::cursor::Cursor; +use metaslang_cst::kinds::KindTypes; +use metaslang_graph_builder::ast::File as GraphBuilderFile; +use metaslang_graph_builder::functions::Functions; +use metaslang_graph_builder::graph::{Edge, Graph, GraphNode, GraphNodeRef, Value}; +use metaslang_graph_builder::{ExecutionConfig, ExecutionError, Variables}; +use once_cell::sync::Lazy; +use stack_graphs::arena::Handle; +use stack_graphs::graph::{File, Node, NodeID, StackGraph}; +use thiserror::Error; + +use crate::builder::{DefinitionBindingInfo, ReferenceBindingInfo}; + +// Node type values +static DROP_SCOPES_TYPE: &str = "drop_scopes"; +static POP_SCOPED_SYMBOL_TYPE: &str = "pop_scoped_symbol"; +static POP_SYMBOL_TYPE: &str = "pop_symbol"; +static PUSH_SCOPED_SYMBOL_TYPE: &str = "push_scoped_symbol"; +static PUSH_SYMBOL_TYPE: &str = "push_symbol"; +static SCOPE_TYPE: &str = "scope"; + +// Node attribute names +static DEBUG_ATTR_PREFIX: &str = "debug_"; +static DEFINIENS_NODE_ATTR: &str = "definiens_node"; +static EMPTY_SOURCE_SPAN_ATTR: &str = "empty_source_span"; +static IS_DEFINITION_ATTR: &str = "is_definition"; +static IS_ENDPOINT_ATTR: &str = "is_endpoint"; +static IS_EXPORTED_ATTR: &str = "is_exported"; +static IS_REFERENCE_ATTR: &str = "is_reference"; +static EXTENSION_HOOK_ATTR: &str = "extension_hook"; +static EXTENSION_SCOPE_ATTR: &str = "extension_scope"; +static INHERIT_EXTENSIONS_ATTR: &str = "inherit_extensions"; +static PARENTS_ATTR: &str = "parents"; +static SCOPE_ATTR: &str = "scope"; +static SOURCE_NODE_ATTR: &str = "source_node"; +static SYMBOL_ATTR: &str = "symbol"; +static SYNTAX_TYPE_ATTR: &str = "syntax_type"; +static TYPE_ATTR: &str = "type"; + +// Expected attributes per node type +static POP_SCOPED_SYMBOL_ATTRS: Lazy> = Lazy::new(|| { + HashSet::from([ + TYPE_ATTR, + SYMBOL_ATTR, + IS_DEFINITION_ATTR, + DEFINIENS_NODE_ATTR, + PARENTS_ATTR, + SYNTAX_TYPE_ATTR, + EXTENSION_SCOPE_ATTR, + INHERIT_EXTENSIONS_ATTR, + ]) +}); +static POP_SYMBOL_ATTRS: Lazy> = Lazy::new(|| { + HashSet::from([ + TYPE_ATTR, + SYMBOL_ATTR, + IS_DEFINITION_ATTR, + DEFINIENS_NODE_ATTR, + PARENTS_ATTR, + SYNTAX_TYPE_ATTR, + EXTENSION_SCOPE_ATTR, + INHERIT_EXTENSIONS_ATTR, + ]) +}); +static PUSH_SCOPED_SYMBOL_ATTRS: Lazy> = Lazy::new(|| { + HashSet::from([ + TYPE_ATTR, + SYMBOL_ATTR, + SCOPE_ATTR, + IS_REFERENCE_ATTR, + PARENTS_ATTR, + ]) +}); +static PUSH_SYMBOL_ATTRS: Lazy> = + Lazy::new(|| HashSet::from([TYPE_ATTR, SYMBOL_ATTR, IS_REFERENCE_ATTR, PARENTS_ATTR])); +static SCOPE_ATTRS: Lazy> = Lazy::new(|| { + HashSet::from([ + TYPE_ATTR, + IS_EXPORTED_ATTR, + IS_ENDPOINT_ATTR, + EXTENSION_HOOK_ATTR, + ]) +}); + +// Edge attribute names +static PRECEDENCE_ATTR: &str = "precedence"; + +// Global variables +/// Name of the variable used to pass the root node. +pub const ROOT_NODE_VAR: &str = "ROOT_NODE"; +/// Name of the variable used to pass the jump to scope node. +pub const JUMP_TO_SCOPE_NODE_VAR: &str = "JUMP_TO_SCOPE_NODE"; +/// Name of the variable used to pass the file path. +pub const FILE_PATH_VAR: &str = "FILE_PATH"; + +pub(crate) struct Loader<'a, KT: KindTypes + 'static> { + msgb: &'a GraphBuilderFile, + functions: &'a Functions, + stack_graph: &'a mut StackGraph, + file: Handle, + tree_cursor: Cursor, + graph: Graph, + remapped_nodes: HashMap, + injected_node_count: usize, + cursors: HashMap, Cursor>, + definitions_info: HashMap, DefinitionBindingInfo>, + references_info: HashMap, ReferenceBindingInfo>, + extension_hooks: HashSet>, +} + +pub(crate) struct LoadResult { + #[cfg(feature = "__private_testing_utils")] + pub graph: Graph, + pub cursors: HashMap, Cursor>, + pub definitions_info: HashMap, DefinitionBindingInfo>, + pub references_info: HashMap, ReferenceBindingInfo>, + // Nodes where we want to inject extensions + pub extension_hooks: HashSet>, +} + +impl<'a, KT: KindTypes + 'static> Loader<'a, KT> { + pub fn new( + msgb: &'a GraphBuilderFile, + functions: &'a Functions, + stack_graph: &'a mut StackGraph, + file: Handle, + tree_cursor: Cursor, + ) -> Self { + Loader { + msgb, + functions, + stack_graph, + file, + tree_cursor, + graph: Graph::new(), + remapped_nodes: HashMap::new(), + injected_node_count: 0, + cursors: HashMap::new(), + definitions_info: HashMap::new(), + references_info: HashMap::new(), + extension_hooks: HashSet::new(), + } + } + + fn build_global_variables(&mut self) -> Variables<'a> { + let mut variables = Variables::new(); + let file_path = self.stack_graph[self.file].name(); + variables + .add(FILE_PATH_VAR.into(), file_path.into()) + .expect("Failed to add FILE_PATH variable"); + + let root_node = self.inject_node(NodeID::root()); + variables + .add(ROOT_NODE_VAR.into(), root_node.into()) + .expect("Failed to set ROOT_NODE"); + + let jump_to_scope_node = self.inject_node(NodeID::jump_to()); + variables + .add(JUMP_TO_SCOPE_NODE_VAR.into(), jump_to_scope_node.into()) + .expect("Failed to set JUMP_TO_SCOPE_NODE"); + + #[cfg(feature = "__private_testing_utils")] + { + // For debugging purposes only + self.graph[root_node] + .attributes + .add( + [DEBUG_ATTR_PREFIX, "msgb_variable"] + .concat() + .as_str() + .into(), + ROOT_NODE_VAR.to_string(), + ) + .expect("Failed to set ROOT_NODE variable name for debugging"); + + self.graph[jump_to_scope_node] + .attributes + .add( + [DEBUG_ATTR_PREFIX, "msgb_variable"] + .concat() + .as_str() + .into(), + JUMP_TO_SCOPE_NODE_VAR.to_string(), + ) + .expect("Failed to set JUMP_TO_SCOPE_NODE variable name for debugging"); + } + + variables + } + + /// Executes this loader. + pub fn execute( + mut self, + cancellation_flag: &dyn CancellationFlag, + ) -> Result, BuildError> { + let variables = self.build_global_variables(); + + let config = ExecutionConfig::new(self.functions, &variables) + .lazy(true) + // .debug_attributes( + // [DEBUG_ATTR_PREFIX, "msgb_location"] + // .concat() + // .as_str() + // .into(), + // [DEBUG_ATTR_PREFIX, "msgb_variable"] + // .concat() + // .as_str() + // .into(), + // [DEBUG_ATTR_PREFIX, "msgb_match_node"] + // .concat() + // .as_str() + // .into(), + // ); + ; + + self.msgb.execute_into( + &mut self.graph, + &self.tree_cursor, + &config, + &(cancellation_flag as &dyn CancellationFlag), + )?; + + self.load(cancellation_flag)?; + + Ok(LoadResult { + #[cfg(feature = "__private_testing_utils")] + graph: self.graph, + cursors: self.cursors, + definitions_info: self.definitions_info, + references_info: self.references_info, + extension_hooks: self.extension_hooks, + }) + } + + /// Create a graph node to represent the stack graph node. It is the callers responsibility to + /// ensure the stack graph node exists. + pub fn inject_node(&mut self, id: NodeID) -> GraphNodeRef { + let node = self.graph.add_graph_node(); + self.remapped_nodes.insert(node.index(), id); + self.injected_node_count += 1; + node + } +} + +/// An error that can occur while loading a stack graph from a TSG file +#[derive(Debug, Error)] +pub enum BuildError { + #[error("{0}")] + Cancelled(&'static str), + #[error("Missing ‘symbol’ attribute on graph node")] + MissingSymbol(GraphNodeRef), + #[error("Missing ‘scope’ attribute on graph node")] + MissingScope(GraphNodeRef), + #[error("Missing ‘definiens’ attribute on graph node")] + MissingDefiniens(GraphNodeRef), + #[error("Unknown ‘{0}’ flag type {1}")] + UnknownFlagType(String, String), + #[error("Unknown node type {0}")] + UnknownNodeType(String), + #[error("Unknown symbol type {0}")] + UnknownSymbolType(String), + #[error(transparent)] + ExecutionError(ExecutionError), + #[error("Expected exported symbol scope in {0}, got {1}")] + SymbolScopeError(String, String), + #[error("Parent must be either a reference or definition")] + InvalidParent(GraphNodeRef), +} + +impl From for BuildError { + fn from(value: stack_graphs::CancellationError) -> Self { + Self::Cancelled(value.0) + } +} + +impl From for BuildError { + fn from(value: ExecutionError) -> Self { + match value { + ExecutionError::Cancelled(err) => Self::Cancelled(err.0), + err => Self::ExecutionError(err), + } + } +} + +impl<'a, KT: KindTypes + 'static> Loader<'a, KT> { + fn load(&mut self, cancellation_flag: &dyn CancellationFlag) -> Result<(), BuildError> { + let cancellation_flag: &dyn stack_graphs::CancellationFlag = &cancellation_flag; + + // By default graph ids are used for stack graph local_ids. A remapping is computed + // for local_ids that already exist in the graph---all other graph ids are mapped to + // the same local_id. See [`self.node_id_for_index`] for more details. + let mut next_local_id = u32::try_from(self.graph.node_count() - self.injected_node_count) + .expect("nodes local_id to fit in u32"); + for node in self.stack_graph.nodes_for_file(self.file) { + let local_id = self.stack_graph[node].id().local_id(); + let index = (local_id as usize) + self.injected_node_count; + // find next available local_id for which no stack graph node exists yet + while self + .stack_graph + .node_for_id(NodeID::new_in_file(self.file, next_local_id)) + .is_some() + { + next_local_id += 1; + } + // remap graph node index to the available stack graph node local_id + if self + .remapped_nodes + .insert(index, NodeID::new_in_file(self.file, next_local_id)) + .is_some() + { + panic!("index already remapped"); + } + } + + // First create a stack graph node for each MSGB node. (The skip(...) is because the first + // DSL nodes that we create are the proxies for the injected stack graph nodes.) + for node_ref in self.graph.iter_nodes().skip(self.injected_node_count) { + cancellation_flag.check("loading graph nodes")?; + let node_type = self.get_node_type(node_ref)?; + let handle = match node_type { + NodeType::DropScopes => self.load_drop_scopes(node_ref), + NodeType::PopScopedSymbol => self.load_pop_scoped_symbol(node_ref)?, + NodeType::PopSymbol => self.load_pop_symbol(node_ref)?, + NodeType::PushScopedSymbol => self.load_push_scoped_symbol(node_ref)?, + NodeType::PushSymbol => self.load_push_symbol(node_ref)?, + NodeType::Scope => self.load_scope(node_ref)?, + }; + self.load_source_info(node_ref, handle)?; + self.load_node_debug_info(node_ref, handle); + } + + // Iterate again to resolve parents attribute, which refers to other nodes in the graph + for node_ref in self.graph.iter_nodes().skip(self.injected_node_count) { + cancellation_flag.check("loading graph nodes additional info")?; + self.load_additional_info(node_ref)?; + } + + for node in self.stack_graph.nodes_for_file(self.file) { + self.verify_node(node)?; + } + + // Then add stack graph edges for each TSG edge. Note that we _don't_ skip(...) here because + // there might be outgoing nodes from the “root” node that we need to process. + // (Technically the caller could add outgoing nodes from “jump to scope” as well, but those + // are invalid according to the stack graph semantics and will never be followed. + for source_ref in self.graph.iter_nodes() { + let source = &self.graph[source_ref]; + let source_node_id = self.node_id_for_graph_node(source_ref); + let source_handle = self.stack_graph.node_for_id(source_node_id).unwrap(); + for (sink_ref, edge) in source.iter_edges() { + cancellation_flag.check("loading graph edges")?; + let precedence = match edge.attributes.get(PRECEDENCE_ATTR) { + Some(precedence) => precedence.as_integer()?, + None => 0, + } + .try_into() + .map_err(|_| ExecutionError::ExpectedInteger("integer does not fit".to_string()))?; + let sink_node_id = self.node_id_for_graph_node(sink_ref); + let sink_handle = self.stack_graph.node_for_id(sink_node_id).unwrap(); + self.stack_graph + .add_edge(source_handle, sink_handle, precedence); + Self::load_edge_debug_info(self.stack_graph, source_handle, sink_handle, edge); + } + } + + Ok(()) + } + + fn get_node_type(&self, node_ref: GraphNodeRef) -> Result { + let node = &self.graph[node_ref]; + let node_type = match node.attributes.get(TYPE_ATTR) { + Some(node_type) => node_type.as_str()?, + None => return Ok(NodeType::Scope), + }; + if node_type == DROP_SCOPES_TYPE { + Ok(NodeType::DropScopes) + } else if node_type == POP_SCOPED_SYMBOL_TYPE { + Ok(NodeType::PopScopedSymbol) + } else if node_type == POP_SYMBOL_TYPE { + Ok(NodeType::PopSymbol) + } else if node_type == PUSH_SCOPED_SYMBOL_TYPE { + Ok(NodeType::PushScopedSymbol) + } else if node_type == PUSH_SYMBOL_TYPE { + Ok(NodeType::PushSymbol) + } else if node_type == SCOPE_TYPE { + Ok(NodeType::Scope) + } else { + Err(BuildError::UnknownNodeType(node_type.to_string())) + } + } + + fn verify_node(&self, node: Handle) -> Result<(), BuildError> { + if let Node::PushScopedSymbol(node) = &self.stack_graph[node] { + let scope = &self.stack_graph[self.stack_graph.node_for_id(node.scope).unwrap()]; + if !scope.is_exported_scope() { + return Err(BuildError::SymbolScopeError( + format!("{}", node.display(self.stack_graph)), + format!("{}", scope.display(self.stack_graph)), + )); + } + } + Ok(()) + } +} + +enum NodeType { + DropScopes, + PopSymbol, + PopScopedSymbol, + PushSymbol, + PushScopedSymbol, + Scope, +} + +impl<'a, KT: KindTypes> Loader<'a, KT> { + /// Get the `NodeID` corresponding to a `Graph` node. + /// + /// By default, graph nodes get their index shifted by [`self.injected_node_count`] as their + /// `local_id`, unless they have a corresponding entry in the [`self.remapped_nodes`] map. This + /// is the case if: + /// 1. The node was injected, in which case it is mapped to the `NodeID` of the injected node. + /// 2. The node's default `local_id` clashes with a preexisting node, in which case it is mapped to + /// an available `local_id` beyond the range of default `local_ids`. + fn node_id_for_graph_node(&self, node_ref: GraphNodeRef) -> NodeID { + let index = node_ref.index(); + self.remapped_nodes.get(&index).map_or_else( + || { + NodeID::new_in_file( + self.file, + u32::try_from(index - self.injected_node_count) + .expect("local_id to fit in u32"), + ) + }, + |id| *id, + ) + } + + fn load_drop_scopes(&mut self, node_ref: GraphNodeRef) -> Handle { + let id = self.node_id_for_graph_node(node_ref); + self.stack_graph.add_drop_scopes_node(id).unwrap() + } + + fn load_pop_scoped_symbol( + &mut self, + node_ref: GraphNodeRef, + ) -> Result, BuildError> { + let node = &self.graph[node_ref]; + let symbol = match node.attributes.get(SYMBOL_ATTR) { + Some(symbol) => Self::load_symbol(symbol)?, + None => return Err(BuildError::MissingSymbol(node_ref)), + }; + let symbol = self.stack_graph.add_symbol(&symbol); + let id = self.node_id_for_graph_node(node_ref); + let is_definition = Self::load_flag(node, IS_DEFINITION_ATTR)?; + Self::verify_attributes(node, POP_SCOPED_SYMBOL_TYPE, &POP_SCOPED_SYMBOL_ATTRS); + let node_handle = self + .stack_graph + .add_pop_scoped_symbol_node(id, symbol, is_definition) + .unwrap(); + Ok(node_handle) + } + + fn load_pop_symbol(&mut self, node_ref: GraphNodeRef) -> Result, BuildError> { + let node = &self.graph[node_ref]; + let symbol = match node.attributes.get(SYMBOL_ATTR) { + Some(symbol) => Self::load_symbol(symbol)?, + None => return Err(BuildError::MissingSymbol(node_ref)), + }; + let symbol = self.stack_graph.add_symbol(&symbol); + let id = self.node_id_for_graph_node(node_ref); + let is_definition = Self::load_flag(node, IS_DEFINITION_ATTR)?; + Self::verify_attributes(node, POP_SYMBOL_TYPE, &POP_SYMBOL_ATTRS); + let node_handle = self + .stack_graph + .add_pop_symbol_node(id, symbol, is_definition) + .unwrap(); + Ok(node_handle) + } + + fn load_push_scoped_symbol( + &mut self, + node_ref: GraphNodeRef, + ) -> Result, BuildError> { + let node = &self.graph[node_ref]; + let symbol = match node.attributes.get(SYMBOL_ATTR) { + Some(symbol) => Self::load_symbol(symbol)?, + None => return Err(BuildError::MissingSymbol(node_ref)), + }; + let symbol = self.stack_graph.add_symbol(&symbol); + let id = self.node_id_for_graph_node(node_ref); + let scope = match node.attributes.get(SCOPE_ATTR) { + Some(scope) => self.node_id_for_graph_node(scope.as_graph_node_ref()?), + None => return Err(BuildError::MissingScope(node_ref)), + }; + let is_reference = Self::load_flag(node, IS_REFERENCE_ATTR)?; + Self::verify_attributes(node, PUSH_SCOPED_SYMBOL_TYPE, &PUSH_SCOPED_SYMBOL_ATTRS); + Ok(self + .stack_graph + .add_push_scoped_symbol_node(id, symbol, scope, is_reference) + .unwrap()) + } + + fn load_push_symbol(&mut self, node_ref: GraphNodeRef) -> Result, BuildError> { + let node = &self.graph[node_ref]; + let symbol = match node.attributes.get(SYMBOL_ATTR) { + Some(symbol) => Self::load_symbol(symbol)?, + None => return Err(BuildError::MissingSymbol(node_ref)), + }; + let symbol = self.stack_graph.add_symbol(&symbol); + let id = self.node_id_for_graph_node(node_ref); + let is_reference = Self::load_flag(node, IS_REFERENCE_ATTR)?; + Self::verify_attributes(node, PUSH_SYMBOL_TYPE, &PUSH_SYMBOL_ATTRS); + Ok(self + .stack_graph + .add_push_symbol_node(id, symbol, is_reference) + .unwrap()) + } + + fn load_scope(&mut self, node_ref: GraphNodeRef) -> Result, BuildError> { + let node = &self.graph[node_ref]; + let id = self.node_id_for_graph_node(node_ref); + let is_exported = + Self::load_flag(node, IS_EXPORTED_ATTR)? || Self::load_flag(node, IS_ENDPOINT_ATTR)?; + Self::verify_attributes(node, SCOPE_TYPE, &SCOPE_ATTRS); + Ok(self.stack_graph.add_scope_node(id, is_exported).unwrap()) + } + + fn load_symbol(value: &Value) -> Result { + match value { + Value::Integer(i) => Ok(i.to_string()), + Value::String(s) => Ok(s.clone()), + _ => Err(BuildError::UnknownSymbolType(value.to_string())), + } + } + + fn load_flag(node: &GraphNode, attribute: &str) -> Result { + match node.attributes.get(attribute) { + Some(value) => value + .as_boolean() + .map_err(|_| BuildError::UnknownFlagType(attribute.to_string(), value.to_string())), + None => Ok(false), + } + } + + fn load_source_info( + &mut self, + node_ref: GraphNodeRef, + node_handle: Handle, + ) -> Result<(), BuildError> { + let node = &self.graph[node_ref]; + + // For every added graph node which links to a corresponding source + // node, save the corresponding CST cursor so our caller can extract + // that info later. + if let Some(source_node) = node.attributes.get(SOURCE_NODE_ATTR) { + let syntax_node_ref = source_node.as_syntax_node_ref()?; + let source_node = &self.graph[syntax_node_ref]; + self.cursors.insert(node_handle, source_node.clone()); + } + + if let Some(syntax_type) = node.attributes.get(SYNTAX_TYPE_ATTR) { + let syntax_type = syntax_type.as_str()?; + let syntax_type = self.stack_graph.add_string(syntax_type); + let source_info = self.stack_graph.source_info_mut(node_handle); + source_info.syntax_type = syntax_type.into(); + } + + Ok(()) + } + + fn node_handle_for_graph_node(&self, node_ref: GraphNodeRef) -> Handle { + self.stack_graph + .node_for_id(self.node_id_for_graph_node(node_ref)) + .expect("parent node exists in the stack graph") + } + + // Saves additional binding information from the loaded graph (eg. tag, + // definiens, import/export nodes and parents). + fn load_additional_info(&mut self, node_ref: GraphNodeRef) -> Result<(), BuildError> { + let node = &self.graph[node_ref]; + let node_handle = self.node_handle_for_graph_node(node_ref); + let stack_graph_node = &self.stack_graph[node_handle]; + + let parents = match node.attributes.get(PARENTS_ATTR) { + Some(parents) => { + parents + .as_list()? + .iter() + .flat_map(|value| { + value + .as_graph_node_ref() + .map(|id| self.node_handle_for_graph_node(id)) + }) + .flat_map(|parent| { + // ensure parents are either definitions or references + let parent_node = &self.stack_graph[parent]; + if !parent_node.is_definition() && !parent_node.is_reference() { + Err(BuildError::InvalidParent(node_ref)) + } else { + Ok(parent) + } + }) + .collect() + } + None => Vec::new(), + }; + + if stack_graph_node.is_definition() { + let definiens = match node.attributes.get(DEFINIENS_NODE_ATTR) { + Some(definiens_node) => { + let syntax_node_ref = definiens_node.as_syntax_node_ref()?; + let definiens_node = &self.graph[syntax_node_ref]; + definiens_node.clone() + } + None => return Err(BuildError::MissingDefiniens(node_ref)), + }; + + let extension_scope = match node.attributes.get(EXTENSION_SCOPE_ATTR) { + Some(extension_scope) => { + Some(self.node_handle_for_graph_node(extension_scope.as_graph_node_ref()?)) + } + None => None, + }; + + let inherit_extensions = Self::load_flag(node, INHERIT_EXTENSIONS_ATTR)?; + + self.definitions_info.insert( + node_handle, + DefinitionBindingInfo { + definiens, + parents, + extension_scope, + inherit_extensions, + }, + ); + } else if stack_graph_node.is_reference() { + self.references_info + .insert(node_handle, ReferenceBindingInfo { parents }); + } + + if Self::load_flag(node, EXTENSION_HOOK_ATTR)? { + self.extension_hooks.insert(node_handle); + } + + Ok(()) + } + + fn load_node_debug_info(&mut self, node_ref: GraphNodeRef, node_handle: Handle) { + let node = &self.graph[node_ref]; + for (name, value) in node.attributes.iter() { + let name = name.to_string(); + if let Some(name_without_prefix) = name.strip_prefix(DEBUG_ATTR_PREFIX) { + let value = match value { + Value::String(value) => value.clone(), + value => value.to_string(), + }; + let key = self.stack_graph.add_string(name_without_prefix); + let value = self.stack_graph.add_string(&value); + self.stack_graph + .node_debug_info_mut(node_handle) + .add(key, value); + } + } + } + + fn load_edge_debug_info( + stack_graph: &mut StackGraph, + source_handle: Handle, + sink_handle: Handle, + edge: &Edge, + ) { + for (name, value) in edge.attributes.iter() { + let name = name.to_string(); + if let Some(name_without_prefix) = name.strip_prefix(DEBUG_ATTR_PREFIX) { + let value = match value { + Value::String(value) => value.clone(), + value => value.to_string(), + }; + let key = stack_graph.add_string(name_without_prefix); + let value = stack_graph.add_string(&value); + stack_graph + .edge_debug_info_mut(source_handle, sink_handle) + .add(key, value); + } + } + } + + fn verify_attributes( + node: &GraphNode, + node_type: &str, + allowed_attributes: &HashSet<&'static str>, + ) { + for (id, _) in node.attributes.iter() { + let id = id.as_str(); + if !allowed_attributes.contains(id) + && id != SOURCE_NODE_ATTR + && id != EMPTY_SOURCE_SPAN_ATTR + && !id.starts_with(DEBUG_ATTR_PREFIX) + { + eprintln!("Unexpected attribute {id} on node of type {node_type}"); + } + } + } +} diff --git a/crates/metaslang/bindings/src/builder/mod.rs b/crates/metaslang/bindings/src/builder/mod.rs index 77943da877..21bdb1609b 100644 --- a/crates/metaslang/bindings/src/builder/mod.rs +++ b/crates/metaslang/bindings/src/builder/mod.rs @@ -1,985 +1,233 @@ -// -*- coding: utf-8 -*- -// ------------------------------------------------------------------------------------------------ -// Copyright © 2021, stack-graphs authors. -// Copyright © 2024, slang authors. -// Licensed under MIT license -// Please see the LICENSE file in the root of this crate for license details. -// ------------------------------------------------------------------------------------------------ - -//! This module lets you construct [stack graphs][] using this crate's [graph construction DSL][]. -//! The graph DSL lets you construct arbitrary graph structures from the parsed syntax tree of a -//! source file. If you construct a graph using the vocabulary of attributes described below, then -//! the result of executing the graph DSL will be a valid stack graph, which we can then use for -//! name binding lookups. -//! -//! ## Prerequisites -//! -//! [stack graphs]: https://docs.rs/stack-graphs/*/ -//! [graph construction DSL]: https://docs.rs/metaslang_graph_builder/*/ -//! -//! To process a particular source language, you'll need to first get the CST from the source, using -//! the parser constructed from the language definition that uses the `metaslang_cst` crate. -//! -//! You will then need to create _stack graph construction rules_ for your language. These rules -//! are implemented using metaslang's [graph construction DSL][], which is based from tree-sitter's -//! graph construction DSL. They define the particular stack graph nodes and edges that should be -//! created for each part of the parsed syntax tree of a source file. -//! -//! ## Graph DSL vocabulary -//! -//! **Please note**: This documentation assumes you are already familiar with stack graphs, and how -//! to use different stack graph node types, and the connectivity between nodes, to implement the -//! name binding semantics of your language. We assume that you know what kind of stack graph you -//! want to produce; this documentation focuses only on the mechanics of _how_ to create that stack -//! graph content. -//! -//! As mentioned above, your stack graph construction rules should create stack graph nodes and -//! edges from the parsed content of a source file. You will use MSGB [stanzas][] to match on -//! different parts of the parsed syntax tree, and create stack graph content for each match. -//! -//! ### Creating stack graph nodes -//! -//! To create a stack graph node for each identifier in a Solidity file, you could use the following -//! MSGB stanza: -//! -//! ``` skip -//! [Identifier] { -//! node new_node -//! } -//! ``` -//! -//! (Here, `node` is a MSGB statement that creates a new node, and `new_node` is the name of a local -//! variable that the new node is assigned to, letting you refer to the new node in the rest of the -//! stanza.) -//! -//! [stanzas]: https://docs.rs/tree-sitter-graph/*/tree_sitter_graph/reference/index.html#high-level-structure -//! -//! By default, this new node will be a _scope node_. If you need to create a different kind of stack -//! graph node, set the `type` attribute on the new node: -//! -//! ``` skip -//! [Identifier] { -//! node new_node -//! attr (new_node) type = "push_symbol" -//! } -//! ``` -//! -//! The valid `type` values are: -//! -//! - `drop_scopes`: a _drop scopes_ node -//! - `pop_symbol`: a _pop symbol_ node -//! - `pop_scoped_symbol`: a _pop scoped symbol_ node -//! - `push_symbol`: a _push symbol_ node -//! - `push_scoped_symbol`: a _push scoped symbol_ node -//! - `scope`: a _scope_ node -//! -//! A node without an explicit `type` attribute is assumed to be of type `scope`. -//! -//! Certain node types — `pop_symbol`, `pop_scoped_symbol`, `push_symbol` and `push_scoped_symbol` — -//! also require you to provide a `symbol` attribute. Its value must be a string, but will typically -//! come from the content of a parsed syntax node using the [`source-text`][] function and a syntax -//! capture: -//! -//! [`source-text`]: https://docs.rs/tree-sitter-graph/*/tree_sitter_graph/reference/functions/index.html#source-text -//! -//! ``` skip -//! @id [Identifier] { -//! node new_node -//! attr (new_node) type = "push_symbol", symbol = (source-text @id) -//! } -//! ``` -//! -//! Node types `pop_symbol` and `pop_scoped_symbol` allow an optional `is_definition` attribute, -//! which marks that node as a proper definition. Node types `push_symbol` and `push_scoped_symbol` -//! allow an optional `is_reference` attribute, which marks the node as a proper reference. When -//! `is_definition` or `is_reference` are set, the `source_node` attribute is required. -//! -//! ``` skip -//! @id [Identifier] { -//! node new_node -//! attr (new_node) type = "push_symbol", symbol = (source-text @id), is_reference, source_node = @id -//! } -//! ``` -//! -//! A _push scoped symbol_ node requires a `scope` attribute. Its value must be a reference to an -//! `exported` node that you've already created. (This is the exported scope node that will be -//! pushed onto the scope stack.) For instance: -//! -//! ``` skip -//! @id [Identifier] { -//! node new_exported_scope_node -//! attr (new_exported_scope_node) is_exported -//! node new_push_scoped_symbol_node -//! attr (new_push_scoped_symbol_node) -//! type = "push_scoped_symbol", -//! symbol = (source-text @id), -//! scope = new_exported_scope_node -//! } -//! ``` -//! -//! Nodes of type `scope` allow an optional `is_exported` attribute, that is required to use the -//! scope in a `push_scoped_symbol` node. -//! -//! -//! ### Annotating nodes with location information -//! -//! You can annotate any stack graph node that you create with location information, identifying -//! the portion of the source file that the node "belongs to". This is _required_ for definition -//! and reference nodes, since the location information determines which parts of the source file -//! the user can _click on_, and the _destination_ of any code navigation queries the user makes. -//! To do this, add a `source_node` attribute, whose value is a syntax node capture: -//! -//! ``` skip -//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { -//! node def -//! attr (def) type = "pop_symbol", symbol = (source-text @id), source_node = @func, is_definition -//! } -//! ``` -//! -//! Note how in this example, we use a different syntax node for the _target_ of the definition -//! (the entirety of the function definition) and for the _name_ of the definition (the content of -//! the function's `name`). -//! -//! Adding the `empty_source_span` attribute will use an empty source span located at the start of -//! the span of the `source_node`. This can be useful when a proper reference or definition is -//! desired, and thus `source_node` is required, but the span of the available source node is too -//! large. For example, a module definition which is located at the start of the program, but does -//! span the whole program: -//! -//! ``` skip -//! @unit [SourceUnit] { -//! ; ... -//! node mod_def -//! attr mod_def type = "pop_symbol", symbol = mod_name, is_definition, source_node = @unit, empty_source_span -//! ; ... -//! } -//! ``` -//! -//! ### Annotating nodes with syntax type information -//! -//! You can annotate any stack graph node with information about its syntax type. To do this, add a -//! `syntax_type` attribute, whose value is a string indicating the syntax type. -//! -//! ``` skip -//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { -//! node def -//! ; ... -//! attr (def) syntax_type = "function" -//! } -//! ``` -//! -//! ### Annotating definitions with definiens information -//! -//! You cannot annotate definitions with a definiens, which is the thing the definition covers. For -//! example, for a function definition, the definiens would be the function body. To do this, add a -//! `definiens_node` attribute, whose value is a syntax node that spans the definiens. -//! -//! ``` skip -//! @func [FunctionDefinition [FunctionName @id [Identifier]] @body [FunctionBody]] { -//! node def -//! ; ... -//! attr (def) definiens_node = @body -//! } -//! ``` -//! -//! Definiens are optional and setting them to `#null` explicitly is allowed. -//! -//! ### Connecting stack graph nodes with edges -//! -//! To connect two stack graph nodes, use the `edge` statement to add an edge between them: -//! -//! ``` skip -//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { -//! node def -//! attr (def) type = "pop_symbol", symbol = (source-text @id), source_node = @func, is_definition -//! node body -//! edge def -> body -//! } -//! ``` -//! -//! To implement shadowing (which determines which definitions are selected when multiple are available), -//! you can add a `precedence` attribute to each edge to indicate which paths are prioritized: -//! -//! ``` skip -//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { -//! node def -//! attr (def) type = "pop_symbol", symbol = (source-text @id), source_node = @func, is_definition -//! node body -//! edge def -> body -//! attr (def -> body) precedence = 1 -//! } -//! ``` -//! -//! (If you don't specify a `precedence`, the default is 0.) -//! -//! ### Referring to the singleton nodes -//! -//! The _root node_ and _jump to scope node_ are singleton nodes that always exist for all stack -//! graphs. You can refer to them using the `ROOT_NODE` and `JUMP_TO_SCOPE_NODE` global variables: -//! -//! ``` skip -//! global ROOT_NODE -//! -//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { -//! node def -//! attr (def) type = "pop_symbol", symbol = (source-text @id), source_node = @func, is_definition -//! edge ROOT_NODE -> def -//! } -//! ``` -//! -//! ### Attaching debug information to nodes -//! -//! It is possible to attach extra information to nodes for debugging purposes. This is done by adding -//! `debug_*` attributes to nodes. Each attribute defines a debug entry, with the key derived from the -//! attribute name, and the value the string representation of the attribute value. For example, mark -//! a scope node with a kind as follows: -//! -//! ``` skip -//! @func [FunctionDefinition [FunctionName @id [Identifier]]] { -//! ; ... -//! node param_scope -//! attr (param_scope) debug_kind = "param_scope" -//! ; ... -//! } -//! ``` -//! -//! ### Other node attributes introduced in Slang's usage of stack-graphs -//! -//! #### `parents` attribute -//! -//! Is used to convey semantic hierarchy. Can be applied to both definitions and -//! references. It's an optional, list of graph nodes attribute. -//! -//! For references it can indicate in which language context the reference -//! occurs (eg. in which method or class). For definitions it can indicate the -//! enclosing type of the definition, or parent classes in a class hierarchy. -//! The parent handles themselves can refer to definitions or references. In the -//! later case, generally speaking they will need to be resolved at resolution -//! time in order to be useful. -//! -//! #### `extension_hook`, `extension_scope` and `inherit_extensions` -//! -//! These attributes enable the bindings API to resolve extension methods by -//! injecting specific scopes at potentially unrelated (lexically speaking) -//! nodes in the stack graph. Availability and application of extension scopes -//! depend on the call site (ie. the reference node). Thus, the extension scope -//! to (potentially) apply when resolving a reference is computed by looking up -//! the `parents` of the reference and then querying those parent nodes for -//! their `extension_scope` (an optional scope node). Any extension providing -//! node can also have the `inherit_extensions` attribute (a boolean) which -//! indicates that the algorithm should recurse and resolve its parents to -//! further look for other extensions scopes. -//! -//! Finally, the attribute `extension_hook` defines where in the graph should -//! these extension scopes be injected. This is typically the root lexical -//! scope. This attribute applies to any scope node and is boolean. -//! - -mod cancellation; -mod functions; +mod loader; +mod resolver; use std::collections::{HashMap, HashSet}; +use std::fmt::Debug; +use std::rc::Rc; -pub use cancellation::{CancellationFlag, NoCancellation}; -pub use functions::default_functions; +use loader::{LoadResult, Loader}; use metaslang_cst::cursor::Cursor; use metaslang_cst::kinds::KindTypes; -use metaslang_graph_builder::ast::File as GraphBuilderFile; +use metaslang_graph_builder::ast::File; use metaslang_graph_builder::functions::Functions; -use metaslang_graph_builder::graph::{Edge, Graph, GraphNode, GraphNodeRef, Value}; -use metaslang_graph_builder::{ExecutionConfig, ExecutionError, Variables}; -use once_cell::sync::Lazy; -use stack_graphs::arena::Handle; -use stack_graphs::graph::{File, Node, NodeID, StackGraph}; -use thiserror::Error; - -use crate::{DefinitionBindingInfo, ReferenceBindingInfo}; - -// Node type values -static DROP_SCOPES_TYPE: &str = "drop_scopes"; -static POP_SCOPED_SYMBOL_TYPE: &str = "pop_scoped_symbol"; -static POP_SYMBOL_TYPE: &str = "pop_symbol"; -static PUSH_SCOPED_SYMBOL_TYPE: &str = "push_scoped_symbol"; -static PUSH_SYMBOL_TYPE: &str = "push_symbol"; -static SCOPE_TYPE: &str = "scope"; - -// Node attribute names -static DEBUG_ATTR_PREFIX: &str = "debug_"; -static DEFINIENS_NODE_ATTR: &str = "definiens_node"; -static EMPTY_SOURCE_SPAN_ATTR: &str = "empty_source_span"; -static IS_DEFINITION_ATTR: &str = "is_definition"; -static IS_ENDPOINT_ATTR: &str = "is_endpoint"; -static IS_EXPORTED_ATTR: &str = "is_exported"; -static IS_REFERENCE_ATTR: &str = "is_reference"; -static EXTENSION_HOOK_ATTR: &str = "extension_hook"; -static EXTENSION_SCOPE_ATTR: &str = "extension_scope"; -static INHERIT_EXTENSIONS_ATTR: &str = "inherit_extensions"; -static PARENTS_ATTR: &str = "parents"; -static SCOPE_ATTR: &str = "scope"; -static SOURCE_NODE_ATTR: &str = "source_node"; -static SYMBOL_ATTR: &str = "symbol"; -static SYNTAX_TYPE_ATTR: &str = "syntax_type"; -static TYPE_ATTR: &str = "type"; - -// Expected attributes per node type -static POP_SCOPED_SYMBOL_ATTRS: Lazy> = Lazy::new(|| { - HashSet::from([ - TYPE_ATTR, - SYMBOL_ATTR, - IS_DEFINITION_ATTR, - DEFINIENS_NODE_ATTR, - PARENTS_ATTR, - SYNTAX_TYPE_ATTR, - EXTENSION_SCOPE_ATTR, - INHERIT_EXTENSIONS_ATTR, - ]) -}); -static POP_SYMBOL_ATTRS: Lazy> = Lazy::new(|| { - HashSet::from([ - TYPE_ATTR, - SYMBOL_ATTR, - IS_DEFINITION_ATTR, - DEFINIENS_NODE_ATTR, - PARENTS_ATTR, - SYNTAX_TYPE_ATTR, - EXTENSION_SCOPE_ATTR, - INHERIT_EXTENSIONS_ATTR, - ]) -}); -static PUSH_SCOPED_SYMBOL_ATTRS: Lazy> = Lazy::new(|| { - HashSet::from([ - TYPE_ATTR, - SYMBOL_ATTR, - SCOPE_ATTR, - IS_REFERENCE_ATTR, - PARENTS_ATTR, - ]) -}); -static PUSH_SYMBOL_ATTRS: Lazy> = - Lazy::new(|| HashSet::from([TYPE_ATTR, SYMBOL_ATTR, IS_REFERENCE_ATTR, PARENTS_ATTR])); -static SCOPE_ATTRS: Lazy> = Lazy::new(|| { - HashSet::from([ - TYPE_ATTR, - IS_EXPORTED_ATTR, - IS_ENDPOINT_ATTR, - EXTENSION_HOOK_ATTR, - ]) -}); - -// Edge attribute names -static PRECEDENCE_ATTR: &str = "precedence"; - -// Global variables -/// Name of the variable used to pass the root node. -pub const ROOT_NODE_VAR: &str = "ROOT_NODE"; -/// Name of the variable used to pass the jump to scope node. -pub const JUMP_TO_SCOPE_NODE_VAR: &str = "JUMP_TO_SCOPE_NODE"; -/// Name of the variable used to pass the file path. -pub const FILE_PATH_VAR: &str = "FILE_PATH"; - -pub(crate) struct Builder<'a, KT: KindTypes + 'static> { - msgb: &'a GraphBuilderFile, - functions: &'a Functions, - stack_graph: &'a mut StackGraph, - file: Handle, - tree_cursor: Cursor, - graph: Graph, - remapped_nodes: HashMap, - injected_node_count: usize, - cursors: HashMap, Cursor>, - definitions_info: HashMap, DefinitionBindingInfo>, - references_info: HashMap, ReferenceBindingInfo>, - extension_hooks: HashSet>, -} - -pub(crate) struct BuildResult { - #[cfg(feature = "__private_testing_utils")] - pub graph: Graph, - pub cursors: HashMap, Cursor>, - pub definitions_info: HashMap, DefinitionBindingInfo>, - pub references_info: HashMap, ReferenceBindingInfo>, - // Nodes where we want to inject extensions - pub extension_hooks: HashSet>, -} - -impl<'a, KT: KindTypes + 'static> Builder<'a, KT> { - pub fn new( - msgb: &'a GraphBuilderFile, - functions: &'a Functions, - stack_graph: &'a mut StackGraph, - file: Handle, - tree_cursor: Cursor, - ) -> Self { - Builder { - msgb, - functions, - stack_graph, - file, - tree_cursor, - graph: Graph::new(), - remapped_nodes: HashMap::new(), - injected_node_count: 0, - cursors: HashMap::new(), - definitions_info: HashMap::new(), - references_info: HashMap::new(), - extension_hooks: HashSet::new(), - } - } +use resolver::Resolver; +use semver::Version; +use stack_graphs::graph::StackGraph; - fn build_global_variables(&mut self) -> Variables<'a> { - let mut variables = Variables::new(); - let file_path = self.stack_graph[self.file].name(); - variables - .add(FILE_PATH_VAR.into(), file_path.into()) - .expect("Failed to add FILE_PATH variable"); - - let root_node = self.inject_node(NodeID::root()); - variables - .add(ROOT_NODE_VAR.into(), root_node.into()) - .expect("Failed to set ROOT_NODE"); - - let jump_to_scope_node = self.inject_node(NodeID::jump_to()); - variables - .add(JUMP_TO_SCOPE_NODE_VAR.into(), jump_to_scope_node.into()) - .expect("Failed to set JUMP_TO_SCOPE_NODE"); - - #[cfg(feature = "__private_testing_utils")] - { - // For debugging purposes only - self.graph[root_node] - .attributes - .add( - [DEBUG_ATTR_PREFIX, "msgb_variable"] - .concat() - .as_str() - .into(), - ROOT_NODE_VAR.to_string(), - ) - .expect("Failed to set ROOT_NODE variable name for debugging"); - - self.graph[jump_to_scope_node] - .attributes - .add( - [DEBUG_ATTR_PREFIX, "msgb_variable"] - .concat() - .as_str() - .into(), - JUMP_TO_SCOPE_NODE_VAR.to_string(), - ) - .expect("Failed to set JUMP_TO_SCOPE_NODE variable name for debugging"); - } - - variables - } +pub(crate) type GraphHandle = stack_graphs::arena::Handle; +pub(crate) type FileHandle = stack_graphs::arena::Handle; +pub(crate) type CursorID = usize; - /// Executes this builder. - pub fn build( - mut self, - cancellation_flag: &dyn CancellationFlag, - ) -> Result, BuildError> { - let variables = self.build_global_variables(); - - let config = ExecutionConfig::new(self.functions, &variables) - .lazy(true) - .debug_attributes( - [DEBUG_ATTR_PREFIX, "msgb_location"] - .concat() - .as_str() - .into(), - [DEBUG_ATTR_PREFIX, "msgb_variable"] - .concat() - .as_str() - .into(), - [DEBUG_ATTR_PREFIX, "msgb_match_node"] - .concat() - .as_str() - .into(), - ); - - self.msgb.execute_into( - &mut self.graph, - &self.tree_cursor, - &config, - &(cancellation_flag as &dyn CancellationFlag), - )?; - - self.load(cancellation_flag)?; - - Ok(BuildResult { - #[cfg(feature = "__private_testing_utils")] - graph: self.graph, - cursors: self.cursors, - definitions_info: self.definitions_info, - references_info: self.references_info, - extension_hooks: self.extension_hooks, - }) - } +pub use crate::graph::BindingGraph; - /// Create a graph node to represent the stack graph node. It is the callers responsibility to - /// ensure the stack graph node exists. - pub fn inject_node(&mut self, id: NodeID) -> GraphNodeRef { - let node = self.graph.add_graph_node(); - self.remapped_nodes.insert(node.index(), id); - self.injected_node_count += 1; - node - } +pub(crate) struct DefinitionBindingInfo { + pub(crate) definiens: Cursor, + parents: Vec, + extension_scope: Option, + inherit_extensions: bool, } -/// An error that can occur while loading a stack graph from a TSG file -#[derive(Debug, Error)] -pub enum BuildError { - #[error("{0}")] - Cancelled(&'static str), - #[error("Missing ‘symbol’ attribute on graph node")] - MissingSymbol(GraphNodeRef), - #[error("Missing ‘scope’ attribute on graph node")] - MissingScope(GraphNodeRef), - #[error("Unknown ‘{0}’ flag type {1}")] - UnknownFlagType(String, String), - #[error("Unknown node type {0}")] - UnknownNodeType(String), - #[error("Unknown symbol type {0}")] - UnknownSymbolType(String), - #[error(transparent)] - ExecutionError(ExecutionError), - #[error("Expected exported symbol scope in {0}, got {1}")] - SymbolScopeError(String, String), - #[error("Parent must be either a reference or definition")] - InvalidParent(GraphNodeRef), +pub(crate) struct ReferenceBindingInfo { + parents: Vec, } -impl From for BuildError { - fn from(value: stack_graphs::CancellationError) -> Self { - Self::Cancelled(value.0) - } +pub struct BindingGraphBuilder { + graph_builder_file: File, + functions: Functions, + pub(crate) stack_graph: StackGraph, + pub(crate) cursors: HashMap>, + pub(crate) definitions_info: HashMap>, + pub(crate) references_info: HashMap, + pub(crate) cursor_to_definitions: HashMap, + pub(crate) cursor_to_references: HashMap, + extension_hooks: HashSet, } -impl From for BuildError { - fn from(value: ExecutionError) -> Self { - match value { - ExecutionError::Cancelled(err) => Self::Cancelled(err.0), - err => Self::ExecutionError(err), - } - } +#[derive(Clone)] +pub enum FileDescriptor { + User(String), + System(String), } -impl<'a, KT: KindTypes + 'static> Builder<'a, KT> { - fn load(&mut self, cancellation_flag: &dyn CancellationFlag) -> Result<(), BuildError> { - let cancellation_flag: &dyn stack_graphs::CancellationFlag = &cancellation_flag; - - // By default graph ids are used for stack graph local_ids. A remapping is computed - // for local_ids that already exist in the graph---all other graph ids are mapped to - // the same local_id. See [`self.node_id_for_index`] for more details. - let mut next_local_id = u32::try_from(self.graph.node_count() - self.injected_node_count) - .expect("nodes local_id to fit in u32"); - for node in self.stack_graph.nodes_for_file(self.file) { - let local_id = self.stack_graph[node].id().local_id(); - let index = (local_id as usize) + self.injected_node_count; - // find next available local_id for which no stack graph node exists yet - while self - .stack_graph - .node_for_id(NodeID::new_in_file(self.file, next_local_id)) - .is_some() - { - next_local_id += 1; - } - // remap graph node index to the available stack graph node local_id - if self - .remapped_nodes - .insert(index, NodeID::new_in_file(self.file, next_local_id)) - .is_some() - { - panic!("index already remapped"); - } - } - - // First create a stack graph node for each MSGB node. (The skip(...) is because the first - // DSL nodes that we create are the proxies for the injected stack graph nodes.) - for node_ref in self.graph.iter_nodes().skip(self.injected_node_count) { - cancellation_flag.check("loading graph nodes")?; - let node_type = self.get_node_type(node_ref)?; - let handle = match node_type { - NodeType::DropScopes => self.load_drop_scopes(node_ref), - NodeType::PopScopedSymbol => self.load_pop_scoped_symbol(node_ref)?, - NodeType::PopSymbol => self.load_pop_symbol(node_ref)?, - NodeType::PushScopedSymbol => self.load_push_scoped_symbol(node_ref)?, - NodeType::PushSymbol => self.load_push_symbol(node_ref)?, - NodeType::Scope => self.load_scope(node_ref)?, - }; - self.load_source_info(node_ref, handle)?; - self.load_node_debug_info(node_ref, handle); - } - - // Iterate again to resolve parents attribute, which refers to other nodes in the graph - for node_ref in self.graph.iter_nodes().skip(self.injected_node_count) { - cancellation_flag.check("loading graph nodes additional info")?; - self.load_additional_info(node_ref)?; - } +#[derive(Debug)] +pub(crate) struct FileDescriptorError; - for node in self.stack_graph.nodes_for_file(self.file) { - self.verify_node(node)?; - } +impl FileDescriptor { + // Internal functions to convert a FileDescriptor to and from a string for + // representation inside the stack graph - // Then add stack graph edges for each TSG edge. Note that we _don't_ skip(...) here because - // there might be outgoing nodes from the “root” node that we need to process. - // (Technically the caller could add outgoing nodes from “jump to scope” as well, but those - // are invalid according to the stack graph semantics and will never be followed. - for source_ref in self.graph.iter_nodes() { - let source = &self.graph[source_ref]; - let source_node_id = self.node_id_for_graph_node(source_ref); - let source_handle = self.stack_graph.node_for_id(source_node_id).unwrap(); - for (sink_ref, edge) in source.iter_edges() { - cancellation_flag.check("loading graph edges")?; - let precedence = match edge.attributes.get(PRECEDENCE_ATTR) { - Some(precedence) => precedence.as_integer()?, - None => 0, - } - .try_into() - .map_err(|_| ExecutionError::ExpectedInteger("integer does not fit".to_string()))?; - let sink_node_id = self.node_id_for_graph_node(sink_ref); - let sink_handle = self.stack_graph.node_for_id(sink_node_id).unwrap(); - self.stack_graph - .add_edge(source_handle, sink_handle, precedence); - Self::load_edge_debug_info(self.stack_graph, source_handle, sink_handle, edge); - } + pub(crate) fn as_string(&self) -> String { + match self { + Self::User(path) => format!("user:{path}"), + Self::System(path) => format!("system:{path}"), } - - Ok(()) } - fn get_node_type(&self, node_ref: GraphNodeRef) -> Result { - let node = &self.graph[node_ref]; - let node_type = match node.attributes.get(TYPE_ATTR) { - Some(node_type) => node_type.as_str()?, - None => return Ok(NodeType::Scope), - }; - if node_type == DROP_SCOPES_TYPE { - Ok(NodeType::DropScopes) - } else if node_type == POP_SCOPED_SYMBOL_TYPE { - Ok(NodeType::PopScopedSymbol) - } else if node_type == POP_SYMBOL_TYPE { - Ok(NodeType::PopSymbol) - } else if node_type == PUSH_SCOPED_SYMBOL_TYPE { - Ok(NodeType::PushScopedSymbol) - } else if node_type == PUSH_SYMBOL_TYPE { - Ok(NodeType::PushSymbol) - } else if node_type == SCOPE_TYPE { - Ok(NodeType::Scope) - } else { - Err(BuildError::UnknownNodeType(node_type.to_string())) - } + pub(crate) fn try_from(value: &str) -> Result { + value + .strip_prefix("user:") + .map(|path| FileDescriptor::User(path.into())) + .or_else(|| { + value + .strip_prefix("system:") + .map(|path| FileDescriptor::System(path.into())) + }) + .ok_or(FileDescriptorError) } - fn verify_node(&self, node: Handle) -> Result<(), BuildError> { - if let Node::PushScopedSymbol(node) = &self.stack_graph[node] { - let scope = &self.stack_graph[self.stack_graph.node_for_id(node.scope).unwrap()]; - if !scope.is_exported_scope() { - return Err(BuildError::SymbolScopeError( - format!("{}", node.display(self.stack_graph)), - format!("{}", scope.display(self.stack_graph)), - )); - } - } - Ok(()) + pub(crate) fn from(value: &str) -> Self { + Self::try_from(value) + .unwrap_or_else(|_| panic!("{value} should be a valid file descriptor")) } -} -enum NodeType { - DropScopes, - PopSymbol, - PopScopedSymbol, - PushSymbol, - PushScopedSymbol, - Scope, -} - -impl<'a, KT: KindTypes> Builder<'a, KT> { - /// Get the `NodeID` corresponding to a `Graph` node. - /// - /// By default, graph nodes get their index shifted by [`self.injected_node_count`] as their - /// `local_id`, unless they have a corresponding entry in the [`self.remapped_nodes`] map. This - /// is the case if: - /// 1. The node was injected, in which case it is mapped to the `NodeID` of the injected node. - /// 2. The node's default `local_id` clashes with a preexisting node, in which case it is mapped to - /// an available `local_id` beyond the range of default `local_ids`. - fn node_id_for_graph_node(&self, node_ref: GraphNodeRef) -> NodeID { - let index = node_ref.index(); - self.remapped_nodes.get(&index).map_or_else( - || { - NodeID::new_in_file( - self.file, - u32::try_from(index - self.injected_node_count) - .expect("local_id to fit in u32"), - ) - }, - |id| *id, - ) + pub fn get_path(&self) -> &str { + match self { + Self::User(path) => path, + Self::System(path) => path, + } } - fn load_drop_scopes(&mut self, node_ref: GraphNodeRef) -> Handle { - let id = self.node_id_for_graph_node(node_ref); - self.stack_graph.add_drop_scopes_node(id).unwrap() + pub fn is_system(&self) -> bool { + matches!(self, Self::System(_)) } - fn load_pop_scoped_symbol( - &mut self, - node_ref: GraphNodeRef, - ) -> Result, BuildError> { - let node = &self.graph[node_ref]; - let symbol = match node.attributes.get(SYMBOL_ATTR) { - Some(symbol) => Self::load_symbol(symbol)?, - None => return Err(BuildError::MissingSymbol(node_ref)), - }; - let symbol = self.stack_graph.add_symbol(&symbol); - let id = self.node_id_for_graph_node(node_ref); - let is_definition = Self::load_flag(node, IS_DEFINITION_ATTR)?; - Self::verify_attributes(node, POP_SCOPED_SYMBOL_TYPE, &POP_SCOPED_SYMBOL_ATTRS); - let node_handle = self - .stack_graph - .add_pop_scoped_symbol_node(id, symbol, is_definition) - .unwrap(); - Ok(node_handle) + pub fn is_user(&self) -> bool { + matches!(self, Self::User(_)) } - fn load_pop_symbol(&mut self, node_ref: GraphNodeRef) -> Result, BuildError> { - let node = &self.graph[node_ref]; - let symbol = match node.attributes.get(SYMBOL_ATTR) { - Some(symbol) => Self::load_symbol(symbol)?, - None => return Err(BuildError::MissingSymbol(node_ref)), - }; - let symbol = self.stack_graph.add_symbol(&symbol); - let id = self.node_id_for_graph_node(node_ref); - let is_definition = Self::load_flag(node, IS_DEFINITION_ATTR)?; - Self::verify_attributes(node, POP_SYMBOL_TYPE, &POP_SYMBOL_ATTRS); - let node_handle = self - .stack_graph - .add_pop_symbol_node(id, symbol, is_definition) - .unwrap(); - Ok(node_handle) + pub fn is_user_path(&self, path: &str) -> bool { + matches!(self, Self::User(user_path) if user_path == path) } +} - fn load_push_scoped_symbol( - &mut self, - node_ref: GraphNodeRef, - ) -> Result, BuildError> { - let node = &self.graph[node_ref]; - let symbol = match node.attributes.get(SYMBOL_ATTR) { - Some(symbol) => Self::load_symbol(symbol)?, - None => return Err(BuildError::MissingSymbol(node_ref)), - }; - let symbol = self.stack_graph.add_symbol(&symbol); - let id = self.node_id_for_graph_node(node_ref); - let scope = match node.attributes.get(SCOPE_ATTR) { - Some(scope) => self.node_id_for_graph_node(scope.as_graph_node_ref()?), - None => return Err(BuildError::MissingScope(node_ref)), - }; - let is_reference = Self::load_flag(node, IS_REFERENCE_ATTR)?; - Self::verify_attributes(node, PUSH_SCOPED_SYMBOL_TYPE, &PUSH_SCOPED_SYMBOL_ATTRS); - Ok(self - .stack_graph - .add_push_scoped_symbol_node(id, symbol, scope, is_reference) - .unwrap()) - } +pub trait PathResolver { + fn resolve_path(&self, context_path: &str, path_to_resolve: &Cursor) -> Option; +} - fn load_push_symbol(&mut self, node_ref: GraphNodeRef) -> Result, BuildError> { - let node = &self.graph[node_ref]; - let symbol = match node.attributes.get(SYMBOL_ATTR) { - Some(symbol) => Self::load_symbol(symbol)?, - None => return Err(BuildError::MissingSymbol(node_ref)), - }; - let symbol = self.stack_graph.add_symbol(&symbol); - let id = self.node_id_for_graph_node(node_ref); - let is_reference = Self::load_flag(node, IS_REFERENCE_ATTR)?; - Self::verify_attributes(node, PUSH_SYMBOL_TYPE, &PUSH_SYMBOL_ATTRS); - Ok(self - .stack_graph - .add_push_symbol_node(id, symbol, is_reference) - .unwrap()) - } +impl BindingGraphBuilder { + pub fn create( + version: Version, + binding_rules: &str, + path_resolver: Rc>, + ) -> Self { + let graph_builder_file = + File::from_str(binding_rules).expect("Bindings stack graph builder parse error"); + let stack_graph = StackGraph::new(); + let functions = loader::default_functions(version, path_resolver); - fn load_scope(&mut self, node_ref: GraphNodeRef) -> Result, BuildError> { - let node = &self.graph[node_ref]; - let id = self.node_id_for_graph_node(node_ref); - let is_exported = - Self::load_flag(node, IS_EXPORTED_ATTR)? || Self::load_flag(node, IS_ENDPOINT_ATTR)?; - Self::verify_attributes(node, SCOPE_TYPE, &SCOPE_ATTRS); - Ok(self.stack_graph.add_scope_node(id, is_exported).unwrap()) + Self { + graph_builder_file, + functions, + stack_graph, + cursors: HashMap::new(), + definitions_info: HashMap::new(), + references_info: HashMap::new(), + cursor_to_definitions: HashMap::new(), + cursor_to_references: HashMap::new(), + extension_hooks: HashSet::new(), + } } - fn load_symbol(value: &Value) -> Result { - match value { - Value::Integer(i) => Ok(i.to_string()), - Value::String(s) => Ok(s.clone()), - _ => Err(BuildError::UnknownSymbolType(value.to_string())), - } + pub fn add_system_file(&mut self, file_path: &str, tree_cursor: Cursor) { + let file_kind = FileDescriptor::System(file_path.into()); + let file = self.stack_graph.get_or_create_file(&file_kind.as_string()); + _ = self.add_file_internal(file, tree_cursor); } - fn load_flag(node: &GraphNode, attribute: &str) -> Result { - match node.attributes.get(attribute) { - Some(value) => value - .as_boolean() - .map_err(|_| BuildError::UnknownFlagType(attribute.to_string(), value.to_string())), - None => Ok(false), - } + pub fn add_user_file(&mut self, file_path: &str, tree_cursor: Cursor) { + let file_kind = FileDescriptor::User(file_path.into()); + let file = self.stack_graph.get_or_create_file(&file_kind.as_string()); + _ = self.add_file_internal(file, tree_cursor); } - fn load_source_info( + #[cfg(feature = "__private_testing_utils")] + pub fn add_user_file_returning_graph( &mut self, - node_ref: GraphNodeRef, - node_handle: Handle, - ) -> Result<(), BuildError> { - let node = &self.graph[node_ref]; - - // For every added graph node which links to a corresponding source - // node, save the corresponding CST cursor so our caller can extract - // that info later. - if let Some(source_node) = node.attributes.get(SOURCE_NODE_ATTR) { - let syntax_node_ref = source_node.as_syntax_node_ref()?; - let source_node = &self.graph[syntax_node_ref]; - self.cursors.insert(node_handle, source_node.clone()); - } - - if let Some(syntax_type) = node.attributes.get(SYNTAX_TYPE_ATTR) { - let syntax_type = syntax_type.as_str()?; - let syntax_type = self.stack_graph.add_string(syntax_type); - let source_info = self.stack_graph.source_info_mut(node_handle); - source_info.syntax_type = syntax_type.into(); + file_path: &str, + tree_cursor: Cursor, + ) -> metaslang_graph_builder::graph::Graph { + let file_kind = FileDescriptor::User(file_path.into()); + let file = self.stack_graph.get_or_create_file(&file_kind.as_string()); + let result = self.add_file_internal(file, tree_cursor); + result.graph + } + + fn add_file_internal(&mut self, file: FileHandle, tree_cursor: Cursor) -> LoadResult { + let loader = Loader::new( + &self.graph_builder_file, + &self.functions, + &mut self.stack_graph, + file, + tree_cursor, + ); + let mut result = loader + .execute(&loader::NoCancellation) + .expect("Internal error while building bindings"); + + for (handle, cursor) in result.cursors.drain() { + let cursor_id = cursor.node().id(); + if self.stack_graph[handle].is_definition() { + self.cursor_to_definitions.insert(cursor_id, handle); + } else { + self.cursor_to_references.insert(cursor_id, handle); + } + self.cursors.insert(handle, cursor); } + self.definitions_info + .extend(result.definitions_info.drain()); + self.references_info.extend(result.references_info.drain()); + self.extension_hooks.extend(result.extension_hooks.drain()); - Ok(()) + result } - fn node_handle_for_graph_node(&self, node_ref: GraphNodeRef) -> Handle { - self.stack_graph - .node_for_id(self.node_id_for_graph_node(node_ref)) - .expect("parent node exists in the stack graph") + pub fn build(self) -> Rc> { + let resolver = Resolver::new(&self); + let resolved_references = resolver.resolve(); + BindingGraph::build(self, resolved_references) } - // Saves additional binding information from the loaded graph (eg. tag, - // definiens, import/export nodes and parents). - fn load_additional_info(&mut self, node_ref: GraphNodeRef) -> Result<(), BuildError> { - let node = &self.graph[node_ref]; - let node_handle = self.node_handle_for_graph_node(node_ref); - let stack_graph_node = &self.stack_graph[node_handle]; - - let parents = match node.attributes.get(PARENTS_ATTR) { - Some(parents) => { - parents - .as_list()? - .iter() - .flat_map(|value| { - value - .as_graph_node_ref() - .map(|id| self.node_handle_for_graph_node(id)) - }) - .flat_map(|parent| { - // ensure parents are either definitions or references - let parent_node = &self.stack_graph[parent]; - if !parent_node.is_definition() && !parent_node.is_reference() { - Err(BuildError::InvalidParent(node_ref)) - } else { - Ok(parent) - } - }) - .collect() - } - None => Vec::new(), - }; - - if stack_graph_node.is_definition() { - let definiens = match node.attributes.get(DEFINIENS_NODE_ATTR) { - Some(definiens_node) => { - let syntax_node_ref = definiens_node.as_syntax_node_ref()?; - let definiens_node = &self.graph[syntax_node_ref]; - Some(definiens_node.clone()) - } - None => None, - }; - - let extension_scope = match node.attributes.get(EXTENSION_SCOPE_ATTR) { - Some(extension_scope) => { - Some(self.node_handle_for_graph_node(extension_scope.as_graph_node_ref()?)) - } - None => None, - }; - - let inherit_extensions = Self::load_flag(node, INHERIT_EXTENSIONS_ATTR)?; - - self.definitions_info.insert( - node_handle, - DefinitionBindingInfo { - definiens, - parents, - extension_scope, - inherit_extensions, - }, - ); - } else if stack_graph_node.is_reference() { + pub(crate) fn get_parents(&self, handle: GraphHandle) -> Vec { + if self.is_definition(handle) { + self.definitions_info + .get(&handle) + .map(|info| info.parents.clone()) + .unwrap_or_default() + } else { self.references_info - .insert(node_handle, ReferenceBindingInfo { parents }); + .get(&handle) + .map(|info| info.parents.clone()) + .unwrap_or_default() } + } - if Self::load_flag(node, EXTENSION_HOOK_ATTR)? { - self.extension_hooks.insert(node_handle); - } + fn is_definition(&self, handle: GraphHandle) -> bool { + self.stack_graph[handle].is_definition() + } - Ok(()) + fn is_reference(&self, handle: GraphHandle) -> bool { + self.stack_graph[handle].is_reference() } - fn load_node_debug_info(&mut self, node_ref: GraphNodeRef, node_handle: Handle) { - let node = &self.graph[node_ref]; - for (name, value) in node.attributes.iter() { - let name = name.to_string(); - if let Some(name_without_prefix) = name.strip_prefix(DEBUG_ATTR_PREFIX) { - let value = match value { - Value::String(value) => value.clone(), - value => value.to_string(), - }; - let key = self.stack_graph.add_string(name_without_prefix); - let value = self.stack_graph.add_string(&value); - self.stack_graph - .node_debug_info_mut(node_handle) - .add(key, value); - } - } + fn get_extension_scope(&self, handle: GraphHandle) -> Option { + self.definitions_info + .get(&handle) + .and_then(|info| info.extension_scope) } - fn load_edge_debug_info( - stack_graph: &mut StackGraph, - source_handle: Handle, - sink_handle: Handle, - edge: &Edge, - ) { - for (name, value) in edge.attributes.iter() { - let name = name.to_string(); - if let Some(name_without_prefix) = name.strip_prefix(DEBUG_ATTR_PREFIX) { - let value = match value { - Value::String(value) => value.clone(), - value => value.to_string(), - }; - let key = stack_graph.add_string(name_without_prefix); - let value = stack_graph.add_string(&value); - stack_graph - .edge_debug_info_mut(source_handle, sink_handle) - .add(key, value); - } - } + fn inherits_extensions(&self, handle: GraphHandle) -> bool { + self.definitions_info + .get(&handle) + .is_some_and(|info| info.inherit_extensions) } - fn verify_attributes( - node: &GraphNode, - node_type: &str, - allowed_attributes: &HashSet<&'static str>, - ) { - for (id, _) in node.attributes.iter() { - let id = id.as_str(); - if !allowed_attributes.contains(id) - && id != SOURCE_NODE_ATTR - && id != EMPTY_SOURCE_SPAN_ATTR - && !id.starts_with(DEBUG_ATTR_PREFIX) - { - eprintln!("Unexpected attribute {id} on node of type {node_type}"); - } - } + fn get_file(&self, handle: GraphHandle) -> Option { + self.stack_graph[handle] + .file() + .map(|file| FileDescriptor::from(self.stack_graph[file].name())) + } + + pub(crate) fn is_extension_hook(&self, node_handle: GraphHandle) -> bool { + self.extension_hooks.contains(&node_handle) } } diff --git a/crates/metaslang/bindings/src/builder/resolver.rs b/crates/metaslang/bindings/src/builder/resolver.rs new file mode 100644 index 0000000000..85244b993c --- /dev/null +++ b/crates/metaslang/bindings/src/builder/resolver.rs @@ -0,0 +1,300 @@ +use std::collections::{HashMap, HashSet}; +use std::iter::once; + +use metaslang_cst::kinds::KindTypes; +use stack_graphs::arena::Handle; +use stack_graphs::graph::{Degree, Edge, StackGraph}; +use stack_graphs::partial::{PartialPath, PartialPaths}; +use stack_graphs::stitching::{ + Database, DatabaseCandidates, ForwardCandidates, ForwardPartialPathStitcher, StitcherConfig, + ToAppendable, +}; +use stack_graphs::{CancellationError, NoCancellation}; + +use super::{BindingGraphBuilder, GraphHandle}; + +pub(crate) struct Resolver<'a, KT: KindTypes + 'static> { + owner: &'a BindingGraphBuilder, + partials: PartialPaths, + database: Database, + references: HashMap>, +} + +impl<'a, KT: KindTypes + 'static> Resolver<'a, KT> { + pub fn new(owner: &'a BindingGraphBuilder) -> Self { + let database = Database::new(); + let partials = PartialPaths::new(); + + let mut resolver = Self { + owner, + partials, + database, + references: HashMap::new(), + }; + resolver.build(); + resolver + } + + fn build(&mut self) { + for file in self.owner.stack_graph.iter_files() { + ForwardPartialPathStitcher::find_minimal_partial_path_set_in_file( + &self.owner.stack_graph, + &mut self.partials, + file, + StitcherConfig::default(), + &NoCancellation, + |stack_graph, partials, path| { + self.database + .add_partial_path(stack_graph, partials, path.clone()); + }, + ) + .expect("Should never be cancelled"); + + self.database.ensure_both_directions(&mut self.partials); + } + } + + fn resolve_parents(&mut self, reference: GraphHandle) -> Vec { + self.owner + .get_parents(reference) + .iter() + .flat_map(|handle| { + if self.owner.is_definition(*handle) { + vec![*handle] + } else { + self.resolve_internal(*handle, false) + } + }) + .collect() + } + + fn resolve_parents_recursively(&mut self, parent: GraphHandle) -> Vec { + let mut results = HashMap::new(); + let mut resolve_queue = Vec::new(); + resolve_queue.push(parent); + while let Some(current) = resolve_queue.pop() { + let current_parents = self.resolve_parents(current); + for current_parent in ¤t_parents { + if !results.contains_key(current_parent) { + resolve_queue.push(*current_parent); + } + } + results.insert(current, current_parents); + } + results.into_values().flatten().collect() + } + + fn resolve_internal( + &mut self, + reference: GraphHandle, + allow_recursion: bool, + ) -> Vec { + if let Some(definitions) = self.references.get(&reference) { + return definitions.clone(); + } + + // Save `PartialPaths` state to restore allocations after the resolution + // is complete + let checkpoint = self.partials.save_checkpoint(); + let mut reference_paths = Vec::new(); + + if allow_recursion { + // look for extension scopes to apply to the reference + let ref_parents = self.resolve_parents(reference); + let mut extensions = HashSet::new(); + for parent in &ref_parents { + if let Some(extension_scope) = self.owner.get_extension_scope(*parent) { + extensions.insert(extension_scope); + } + + if self.owner.inherits_extensions(*parent) { + let grand_parents = self.resolve_parents_recursively(*parent); + for grand_parent in &grand_parents { + if let Some(extension_scope) = self.owner.get_extension_scope(*grand_parent) + { + extensions.insert(extension_scope); + } + } + } + } + let extensions = extensions.drain().collect::>(); + let mut database = ExtendedDatabase::new(&mut self.database); + + ForwardPartialPathStitcher::find_all_complete_partial_paths( + &mut DatabaseCandidatesExtended::new( + self.owner, + &mut self.partials, + &mut database, + extensions, + ), + once(reference), + StitcherConfig::default(), + &NoCancellation, + |_graph, _partials, path| { + reference_paths.push(path.clone()); + }, + ) + .expect("not cancelled"); + } else { + ForwardPartialPathStitcher::find_all_complete_partial_paths( + &mut DatabaseCandidates::new( + &self.owner.stack_graph, + &mut self.partials, + &mut self.database, + ), + once(reference), + StitcherConfig::default(), + &NoCancellation, + |_graph, _partials, path| { + reference_paths.push(path.clone()); + }, + ) + .expect("not cancelled"); + } + + let mut results = Vec::new(); + for reference_path in &reference_paths { + let end_node = reference_path.end_node; + + if reference_paths + .iter() + .all(|other| !other.shadows(&mut self.partials, reference_path)) + { + results.push(end_node); + } + } + + // Reclaim arena memory used for this resolution + self.partials.restore_checkpoint(checkpoint); + results + } + + pub(crate) fn resolve(mut self) -> HashMap> { + for handle in self.owner.stack_graph.iter_nodes() { + if self.owner.is_reference(handle) + && self + .owner + .get_file(handle) + .is_some_and(|file| file.is_user()) + { + let definition_handles = self.resolve_internal(handle, true); + self.references.insert(handle, definition_handles); + } + } + self.references + } +} + +// This is a partial paths database, but we also need to keep track of edges +// added to connect to extension scopes +struct ExtendedDatabase<'a> { + pub database: &'a mut Database, + pub edges: Vec, +} + +impl<'a> ExtendedDatabase<'a> { + fn new(database: &'a mut Database) -> Self { + Self { + database, + edges: Vec::new(), + } + } +} + +// These are handles to partial paths or edges in `ExtendedDatabase` +#[derive(Clone, Debug)] +enum ExtendedHandle { + Handle(Handle), + Edge(usize), +} + +impl ToAppendable for ExtendedDatabase<'_> { + fn get_appendable<'a>(&'a self, handle: &'a ExtendedHandle) -> &'a PartialPath { + match handle { + ExtendedHandle::Handle(handle) => self.database.get_appendable(handle), + ExtendedHandle::Edge(edge) => &self.edges[*edge], + } + } +} + +struct DatabaseCandidatesExtended<'a, KT: KindTypes + 'static> { + owner: &'a BindingGraphBuilder, + partials: &'a mut PartialPaths, + database: &'a mut ExtendedDatabase<'a>, + extensions: Vec, +} + +impl<'a, KT: KindTypes + 'static> DatabaseCandidatesExtended<'a, KT> { + fn new( + owner: &'a BindingGraphBuilder, + partials: &'a mut PartialPaths, + database: &'a mut ExtendedDatabase<'a>, + extensions: Vec, + ) -> Self { + Self { + owner, + partials, + database, + extensions, + } + } +} + +impl<'a, KT: KindTypes + 'static> + ForwardCandidates, CancellationError> + for DatabaseCandidatesExtended<'a, KT> +{ + // Return the forward candidates from the encapsulated `Database` and inject + // the extension edges if the given path's end is an extension hook + fn get_forward_candidates(&mut self, path: &PartialPath, result: &mut R) + where + R: std::iter::Extend, + { + let node = path.end_node; + + let mut db_candidates = Vec::new(); + self.database.database.find_candidate_partial_paths( + &self.owner.stack_graph, + self.partials, + path, + &mut db_candidates, + ); + result.extend( + db_candidates + .iter() + .map(|candidate| ExtendedHandle::Handle(*candidate)), + ); + + if self.owner.is_extension_hook(node) { + for extension in &self.extensions { + let edge = Edge { + source: node, + sink: *extension, + precedence: 0, + }; + let mut partial_path = + PartialPath::from_node(&self.owner.stack_graph, self.partials, node); + partial_path + .append(&self.owner.stack_graph, self.partials, edge) + .expect("path can be extended"); + let edge_handle = self.database.edges.len(); + self.database.edges.push(partial_path); + result.extend(once(ExtendedHandle::Edge(edge_handle))); + } + } + } + + fn get_joining_candidate_degree(&self, path: &PartialPath) -> Degree { + // TODO: this may not be correct for extension scopes, but it's only + // used for cycle detection + self.database + .database + .get_incoming_path_degree(path.end_node) + } + + fn get_graph_partials_and_db( + &mut self, + ) -> (&StackGraph, &mut PartialPaths, &ExtendedDatabase<'a>) { + (&self.owner.stack_graph, self.partials, self.database) + } +} diff --git a/crates/metaslang/bindings/src/graph/definition.rs b/crates/metaslang/bindings/src/graph/definition.rs new file mode 100644 index 0000000000..fdfb0574c6 --- /dev/null +++ b/crates/metaslang/bindings/src/graph/definition.rs @@ -0,0 +1,96 @@ +use std::fmt::{self, Debug, Display}; +use std::rc::Rc; + +use metaslang_cst::cursor::Cursor; +use metaslang_cst::kinds::KindTypes; + +use super::{BindingGraph, BindingLocation}; +use crate::builder::{FileDescriptor, GraphHandle}; +use crate::graph::DisplayCursor; + +#[derive(Clone)] +pub struct Definition { + pub(crate) owner: Rc>, + pub(crate) handle: GraphHandle, +} + +impl Definition { + pub fn id(&self) -> usize { + self.get_cursor().node().id() + } + + pub fn name_location(&self) -> BindingLocation { + match self.get_file() { + FileDescriptor::System(_) => BindingLocation::built_in(), + FileDescriptor::User(file_id) => { + BindingLocation::user_file(file_id, self.get_cursor().to_owned()) + } + } + } + + pub fn definiens_location(&self) -> BindingLocation { + match self.get_file() { + FileDescriptor::System(_) => BindingLocation::built_in(), + FileDescriptor::User(file_id) => { + BindingLocation::user_file(file_id, self.get_definiens_cursor().to_owned()) + } + } + } + + pub fn get_cursor(&self) -> &Cursor { + &self + .owner + .definitions + .get(&self.handle) + .expect("Definition handle is valid") + .cursor + } + + pub fn get_definiens_cursor(&self) -> &Cursor { + &self + .owner + .definitions + .get(&self.handle) + .expect("Definition handle is valid") + .definiens + } + + pub fn get_file(&self) -> FileDescriptor { + self.owner + .get_file( + self.owner + .definitions + .get(&self.handle) + .expect("Definition handle is valid") + .file, + ) + .expect("Definition does not have a valid file descriptor") + } +} + +impl Display for Definition { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "definition {}", + DisplayCursor { + cursor: self.get_cursor(), + file: self.get_file() + } + ) + } +} + +impl Debug for Definition { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{self}") + } +} + +impl PartialEq for Definition { + fn eq(&self, other: &Self) -> bool { + Rc::ptr_eq(&self.owner, &other.owner) && self.handle == other.handle + } +} + +impl Eq for Definition {} diff --git a/crates/metaslang/bindings/src/location/mod.rs b/crates/metaslang/bindings/src/graph/location.rs similarity index 100% rename from crates/metaslang/bindings/src/location/mod.rs rename to crates/metaslang/bindings/src/graph/location.rs diff --git a/crates/metaslang/bindings/src/graph/mod.rs b/crates/metaslang/bindings/src/graph/mod.rs new file mode 100644 index 0000000000..935df7fe0a --- /dev/null +++ b/crates/metaslang/bindings/src/graph/mod.rs @@ -0,0 +1,159 @@ +mod definition; +mod location; +mod reference; + +use std::collections::{BTreeMap, HashMap}; +use std::fmt; +use std::rc::Rc; + +pub use definition::Definition; +pub use location::{BindingLocation, BuiltInLocation, UserFileLocation}; +use metaslang_cst::cursor::Cursor; +use metaslang_cst::kinds::KindTypes; +pub use reference::Reference; + +use crate::builder::{CursorID, FileDescriptor, FileHandle, GraphHandle}; +use crate::BindingGraphBuilder; + +struct DefinitionInfo { + file: FileHandle, + cursor: Cursor, + definiens: Cursor, +} + +struct ReferenceInfo { + file: FileHandle, + cursor: Cursor, +} + +pub struct BindingGraph { + files: HashMap, + definitions: BTreeMap>, + references: BTreeMap>, + cursor_to_definitions: HashMap, + cursor_to_references: HashMap, + resolved_references: HashMap>, +} + +impl BindingGraph { + pub(crate) fn build( + builder: BindingGraphBuilder, + resolved_references: HashMap>, + ) -> Rc { + let mut files = HashMap::new(); + for handle in builder.stack_graph.iter_files() { + files.insert( + handle, + FileDescriptor::from(builder.stack_graph[handle].name()), + ); + } + let mut definitions = BTreeMap::new(); + let mut references = BTreeMap::new(); + for handle in builder.stack_graph.iter_nodes() { + let graph_node = &builder.stack_graph[handle]; + let Some(file) = graph_node.file() else { + continue; + }; + if graph_node.is_definition() { + let cursor = builder + .cursors + .get(&handle) + .expect("Definition to have a valid cursor") + .clone(); + let definiens = builder.definitions_info[&handle].definiens.clone(); + definitions.insert( + handle, + DefinitionInfo { + file, + cursor, + definiens, + }, + ); + } else if graph_node.is_reference() { + let cursor = builder + .cursors + .get(&handle) + .expect("Reference to have a valid cursor") + .clone(); + references.insert(handle, ReferenceInfo { file, cursor }); + } + } + + Rc::new(Self { + files, + definitions, + references, + cursor_to_definitions: builder.cursor_to_definitions, + cursor_to_references: builder.cursor_to_references, + resolved_references, + }) + } + + pub fn all_definitions(self: &Rc) -> impl Iterator> + '_ { + self.definitions.keys().map(|handle| Definition { + owner: Rc::clone(self), + handle: *handle, + }) + } + + fn to_definition(self: &Rc, handle: GraphHandle) -> Option> { + if self.definitions.contains_key(&handle) { + Some(Definition { + owner: Rc::clone(self), + handle, + }) + } else { + None + } + } + + pub fn all_references(self: &Rc) -> impl Iterator> + '_ { + self.references.keys().map(|handle| Reference { + owner: Rc::clone(self), + handle: *handle, + }) + } + + pub fn definition_at(self: &Rc, cursor: &Cursor) -> Option> { + let cursor_id = cursor.node().id(); + self.cursor_to_definitions + .get(&cursor_id) + .map(|handle| Definition { + owner: Rc::clone(self), + handle: *handle, + }) + } + + pub fn reference_at(self: &Rc, cursor: &Cursor) -> Option> { + let cursor_id = cursor.node().id(); + self.cursor_to_references + .get(&cursor_id) + .map(|handle| Reference { + owner: Rc::clone(self), + handle: *handle, + }) + } + + fn get_file(&self, handle: FileHandle) -> Option { + self.files.get(&handle).cloned() + } +} + +struct DisplayCursor<'a, KT: KindTypes + 'static> { + cursor: &'a Cursor, + file: FileDescriptor, +} + +impl<'a, KT: KindTypes + 'static> fmt::Display for DisplayCursor<'a, KT> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let offset = self.cursor.text_offset(); + write!( + f, + "`{}` at {}:{}:{}", + self.cursor.node().unparse(), + self.file.get_path(), + offset.line + 1, + offset.column + 1, + ) + } +} diff --git a/crates/metaslang/bindings/src/graph/reference.rs b/crates/metaslang/bindings/src/graph/reference.rs new file mode 100644 index 0000000000..6131dc1e8a --- /dev/null +++ b/crates/metaslang/bindings/src/graph/reference.rs @@ -0,0 +1,81 @@ +use std::fmt::{self, Display}; +use std::rc::Rc; + +use metaslang_cst::cursor::Cursor; +use metaslang_cst::kinds::KindTypes; + +use super::{BindingGraph, BindingLocation, Definition}; +use crate::builder::{FileDescriptor, GraphHandle}; +use crate::graph::DisplayCursor; + +#[derive(Clone)] +pub struct Reference { + pub(crate) owner: Rc>, + pub(crate) handle: GraphHandle, +} + +impl Reference { + pub fn id(&self) -> usize { + self.get_cursor().node().id() + } + + pub fn location(&self) -> BindingLocation { + match self.get_file() { + FileDescriptor::System(_) => BindingLocation::built_in(), + FileDescriptor::User(file_id) => { + BindingLocation::user_file(file_id, self.get_cursor().to_owned()) + } + } + } + + pub fn get_cursor(&self) -> &Cursor { + &self + .owner + .references + .get(&self.handle) + .expect("Reference handle is valid") + .cursor + } + + pub fn get_file(&self) -> FileDescriptor { + self.owner + .get_file( + self.owner + .references + .get(&self.handle) + .expect("Reference handle is valid") + .file, + ) + .expect("Reference does not have a valid file descriptor") + } + + pub fn definitions(&self) -> Vec> { + self.owner.resolved_references[&self.handle] + .iter() + .map(|handle| { + self.owner + .to_definition(*handle) + .expect("Resolved reference handle to be a definition") + }) + .collect() + } +} + +impl Display for Reference { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "reference {}", + DisplayCursor { + cursor: self.get_cursor(), + file: self.get_file() + } + ) + } +} + +impl PartialEq for Reference { + fn eq(&self, other: &Self) -> bool { + Rc::ptr_eq(&self.owner, &other.owner) && self.handle == other.handle + } +} diff --git a/crates/metaslang/bindings/src/lib.rs b/crates/metaslang/bindings/src/lib.rs index 1588e48bdc..23aeeb700b 100644 --- a/crates/metaslang/bindings/src/lib.rs +++ b/crates/metaslang/bindings/src/lib.rs @@ -1,471 +1,7 @@ mod builder; -mod location; -mod resolver; +mod graph; -use std::collections::{HashMap, HashSet}; -use std::fmt::{self, Debug, Display}; -use std::hash::Hash; -use std::rc::Rc; - -use builder::BuildResult; -use metaslang_cst::cursor::Cursor; -use metaslang_cst::kinds::KindTypes; -use metaslang_graph_builder::ast::File; -use metaslang_graph_builder::functions::Functions; -use resolver::{ResolveOptions, Resolver}; -use semver::Version; -use stack_graphs::graph::StackGraph; - -type Builder<'a, KT> = builder::Builder<'a, KT>; -type GraphHandle = stack_graphs::arena::Handle; -type FileHandle = stack_graphs::arena::Handle; -type CursorID = usize; - -pub use location::{BindingLocation, BuiltInLocation, UserFileLocation}; - -pub(crate) struct DefinitionBindingInfo { - definiens: Option>, - parents: Vec, - extension_scope: Option, - inherit_extensions: bool, -} - -pub(crate) struct ReferenceBindingInfo { - parents: Vec, -} - -pub struct BindingGraph { - graph_builder_file: File, - functions: Functions, - stack_graph: StackGraph, - cursors: HashMap>, - definitions_info: HashMap>, - references_info: HashMap, - cursor_to_definitions: HashMap, - cursor_to_references: HashMap, - extension_hooks: HashSet, -} - -pub enum FileDescriptor { - User(String), - System(String), -} - -#[derive(Debug)] -pub(crate) struct FileDescriptorError; - -impl FileDescriptor { - // Internal functions to convert a FileDescriptor to and from a string for - // representation inside the stack graph - - pub(crate) fn as_string(&self) -> String { - match self { - Self::User(path) => format!("user:{path}"), - Self::System(path) => format!("system:{path}"), - } - } - - pub(crate) fn try_from(value: &str) -> Result { - value - .strip_prefix("user:") - .map(|path| FileDescriptor::User(path.into())) - .or_else(|| { - value - .strip_prefix("system:") - .map(|path| FileDescriptor::System(path.into())) - }) - .ok_or(FileDescriptorError) - } - - pub(crate) fn from(value: &str) -> Self { - Self::try_from(value) - .unwrap_or_else(|_| panic!("{value} should be a valid file descriptor")) - } - - pub fn get_path(&self) -> &str { - match self { - Self::User(path) => path, - Self::System(path) => path, - } - } - - pub fn is_system(&self) -> bool { - matches!(self, Self::System(_)) - } - - pub fn is_user(&self) -> bool { - matches!(self, Self::User(_)) - } - - pub fn is_user_path(&self, path: &str) -> bool { - matches!(self, Self::User(user_path) if user_path == path) - } -} - -pub trait PathResolver { - fn resolve_path(&self, context_path: &str, path_to_resolve: &Cursor) -> Option; -} - -impl BindingGraph { - pub fn create( - version: Version, - binding_rules: &str, - path_resolver: Rc>, - ) -> Self { - let graph_builder_file = - File::from_str(binding_rules).expect("Bindings stack graph builder parse error"); - let stack_graph = StackGraph::new(); - let functions = builder::default_functions(version, path_resolver); - - Self { - graph_builder_file, - functions, - stack_graph, - cursors: HashMap::new(), - definitions_info: HashMap::new(), - references_info: HashMap::new(), - cursor_to_definitions: HashMap::new(), - cursor_to_references: HashMap::new(), - extension_hooks: HashSet::new(), - } - } - - pub fn add_system_file(&mut self, file_path: &str, tree_cursor: Cursor) { - let file_kind = FileDescriptor::System(file_path.into()); - let file = self.stack_graph.get_or_create_file(&file_kind.as_string()); - _ = self.add_file_internal(file, tree_cursor); - } - - pub fn add_user_file(&mut self, file_path: &str, tree_cursor: Cursor) { - let file_kind = FileDescriptor::User(file_path.into()); - let file = self.stack_graph.get_or_create_file(&file_kind.as_string()); - _ = self.add_file_internal(file, tree_cursor); - } - - #[cfg(feature = "__private_testing_utils")] - pub fn add_user_file_returning_graph( - &mut self, - file_path: &str, - tree_cursor: Cursor, - ) -> metaslang_graph_builder::graph::Graph { - let file_kind = FileDescriptor::User(file_path.into()); - let file = self.stack_graph.get_or_create_file(&file_kind.as_string()); - let result = self.add_file_internal(file, tree_cursor); - result.graph - } - - fn add_file_internal(&mut self, file: FileHandle, tree_cursor: Cursor) -> BuildResult { - let builder = Builder::new( - &self.graph_builder_file, - &self.functions, - &mut self.stack_graph, - file, - tree_cursor, - ); - let mut result = builder - .build(&builder::NoCancellation) - .expect("Internal error while building bindings"); - - for (handle, cursor) in result.cursors.drain() { - let cursor_id = cursor.node().id(); - if self.stack_graph[handle].is_definition() { - self.cursor_to_definitions.insert(cursor_id, handle); - } else { - self.cursor_to_references.insert(cursor_id, handle); - } - self.cursors.insert(handle, cursor); - } - self.definitions_info - .extend(result.definitions_info.drain()); - self.references_info.extend(result.references_info.drain()); - self.extension_hooks.extend(result.extension_hooks.drain()); - - result - } - - fn to_definition(&self, handle: GraphHandle) -> Option> { - if self.stack_graph[handle].is_definition() { - Some(Definition { - owner: self, - handle, - }) - } else { - None - } - } - - pub fn all_definitions(&self) -> impl Iterator> + '_ { - self.stack_graph - .iter_nodes() - .filter_map(|handle| self.to_definition(handle)) - } - - fn to_reference(&self, handle: GraphHandle) -> Option> { - if self.stack_graph[handle].is_reference() { - Some(Reference { - owner: self, - handle, - }) - } else { - None - } - } - - pub fn all_references(&self) -> impl Iterator> + '_ { - self.stack_graph - .iter_nodes() - .filter_map(|handle| self.to_reference(handle)) - } - - pub fn definition_at(&self, cursor: &Cursor) -> Option> { - let cursor_id = cursor.node().id(); - self.cursor_to_definitions - .get(&cursor_id) - .map(|handle| Definition { - owner: self, - handle: *handle, - }) - } - - pub fn reference_at(&self, cursor: &Cursor) -> Option> { - let cursor_id = cursor.node().id(); - self.cursor_to_references - .get(&cursor_id) - .map(|handle| Reference { - owner: self, - handle: *handle, - }) - } - - fn resolve_handles(&self, handles: &[GraphHandle]) -> Vec> { - // NOTE: the Builder ensures that all handles in the parents are - // either definitions or references - handles - .iter() - .flat_map(|handle| { - if self.stack_graph[*handle].is_definition() { - vec![self.to_definition(*handle).unwrap()] - } else { - self.to_reference(*handle).unwrap().non_recursive_resolve() - } - }) - .collect() - } - - pub(crate) fn is_extension_hook(&self, node_handle: GraphHandle) -> bool { - self.extension_hooks.contains(&node_handle) - } -} - -struct DisplayCursor<'a, KT: KindTypes + 'static> { - cursor: &'a Cursor, - file: FileDescriptor, -} - -impl<'a, KT: KindTypes + 'static> fmt::Display for DisplayCursor<'a, KT> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let offset = self.cursor.text_offset(); - write!( - f, - "`{}` at {}:{}:{}", - self.cursor.node().unparse(), - self.file.get_path(), - offset.line + 1, - offset.column + 1, - ) - } -} - -#[derive(Clone)] -pub struct Definition<'a, KT: KindTypes + 'static> { - owner: &'a BindingGraph, - handle: GraphHandle, -} - -impl<'a, KT: KindTypes + 'static> Definition<'a, KT> { - pub fn id(&self) -> usize { - self.get_cursor().node().id() - } - - pub fn name_location(&self) -> BindingLocation { - match self.get_file() { - FileDescriptor::System(_) => BindingLocation::built_in(), - FileDescriptor::User(file_id) => { - BindingLocation::user_file(file_id, self.get_cursor().to_owned()) - } - } - } - - pub fn definiens_location(&self) -> BindingLocation { - match self.get_file() { - FileDescriptor::System(_) => BindingLocation::built_in(), - FileDescriptor::User(file_id) => { - BindingLocation::user_file(file_id, self.get_definiens_cursor().to_owned()) - } - } - } - - pub fn get_cursor(&self) -> &Cursor { - self.owner - .cursors - .get(&self.handle) - .expect("Definition does not have a valid cursor") - } - - pub fn get_definiens_cursor(&self) -> &Cursor { - self.owner - .definitions_info - .get(&self.handle) - .expect("Definition does not have valid binding info") - .definiens - .as_ref() - .expect("Definiens does not have a valid cursor") - } - - pub fn get_file(&self) -> FileDescriptor { - self.owner.stack_graph[self.handle] - .file() - .map(|file| FileDescriptor::from(self.owner.stack_graph[file].name())) - .expect("Definition does not have a valid file descriptor") - } - - pub(crate) fn resolve_parents(&self) -> Vec> { - self.owner - .definitions_info - .get(&self.handle) - .map(|info| &info.parents) - .map(|handles| self.owner.resolve_handles(handles)) - .unwrap_or_default() - } - - pub(crate) fn get_extension_scope(&self) -> Option { - self.owner - .definitions_info - .get(&self.handle) - .and_then(|info| info.extension_scope) - } - - pub(crate) fn inherit_extensions(&self) -> bool { - self.owner - .definitions_info - .get(&self.handle) - .map_or(false, |info| info.inherit_extensions) - } -} - -impl Display for Definition<'_, KT> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!( - f, - "definition {}", - DisplayCursor { - cursor: self.get_cursor(), - file: self.get_file() - } - ) - } -} - -impl Debug for Definition<'_, KT> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "{self}") - } -} - -impl PartialEq for Definition<'_, KT> { - fn eq(&self, other: &Self) -> bool { - let our_owner: *const BindingGraph = self.owner; - let other_owner: *const BindingGraph = other.owner; - our_owner == other_owner && self.handle == other.handle - } -} - -impl Eq for Definition<'_, KT> {} - -impl Hash for Definition<'_, KT> { - fn hash(&self, state: &mut H) { - let owner: *const BindingGraph = self.owner; - owner.hash(state); - self.handle.hash(state); - } -} - -#[derive(Clone)] -pub struct Reference<'a, KT: KindTypes + 'static> { - owner: &'a BindingGraph, - handle: GraphHandle, -} - -pub enum ResolutionError<'a, KT: KindTypes + 'static> { - Unresolved, - AmbiguousDefinitions(Vec>), -} - -impl<'a, KT: KindTypes + 'static> Reference<'a, KT> { - pub fn id(&self) -> usize { - self.get_cursor().node().id() - } - - pub fn location(&self) -> BindingLocation { - match self.get_file() { - FileDescriptor::System(_) => BindingLocation::built_in(), - FileDescriptor::User(file_id) => { - BindingLocation::user_file(file_id, self.get_cursor().to_owned()) - } - } - } - - pub fn get_cursor(&self) -> &Cursor { - self.owner - .cursors - .get(&self.handle) - .expect("Reference does not have a valid cursor") - } - - pub fn get_file(&self) -> FileDescriptor { - self.owner.stack_graph[self.handle] - .file() - .map(|file| FileDescriptor::from(self.owner.stack_graph[file].name())) - .expect("Reference does not have a valid file descriptor") - } - - pub fn definitions(&self) -> Vec> { - Resolver::build_for(self, ResolveOptions::Full).all() - } - - pub(crate) fn non_recursive_resolve(&self) -> Vec> { - // This was likely originated from a full resolution call, so cut - // recursion here by restricting the resolution algorithm. - Resolver::build_for(self, ResolveOptions::NonRecursive).all() - } - - pub(crate) fn resolve_parents(&self) -> Vec> { - self.owner - .references_info - .get(&self.handle) - .map(|info| &info.parents) - .map(|handles| self.owner.resolve_handles(handles)) - .unwrap_or_default() - } -} - -impl Display for Reference<'_, KT> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!( - f, - "reference {}", - DisplayCursor { - cursor: self.get_cursor(), - file: self.get_file() - } - ) - } -} - -impl PartialEq for Reference<'_, KT> { - fn eq(&self, other: &Self) -> bool { - let our_owner: *const BindingGraph = self.owner; - let other_owner: *const BindingGraph = other.owner; - our_owner == other_owner && self.handle == other.handle - } -} +pub use builder::{BindingGraphBuilder, PathResolver}; +pub use graph::{ + BindingGraph, BindingLocation, BuiltInLocation, Definition, Reference, UserFileLocation, +}; diff --git a/crates/metaslang/bindings/src/resolver/mod.rs b/crates/metaslang/bindings/src/resolver/mod.rs deleted file mode 100644 index 0faec8248c..0000000000 --- a/crates/metaslang/bindings/src/resolver/mod.rs +++ /dev/null @@ -1,212 +0,0 @@ -use std::collections::{HashMap, HashSet}; -use std::iter::once; - -use metaslang_cst::kinds::KindTypes; -use stack_graphs::graph::{Degree, Edge, StackGraph}; -use stack_graphs::partial::{PartialPath, PartialPaths}; -use stack_graphs::stitching::{ - ForwardCandidates, ForwardPartialPathStitcher, GraphEdgeCandidates, GraphEdges, StitcherConfig, -}; -use stack_graphs::CancellationError; - -use crate::{BindingGraph, Definition, FileHandle, GraphHandle, Reference}; - -/// The resolver executes algorithms to resolve a reference to one or more -/// definitions. The reference may not be resolvable in the current state of the -/// bindings (eg. you may still need to add an imported file), so it may not be -/// able to find any definitions, or the definitions it finds may be an -/// incomplete set (eg. finding only an import alias, but not the actual -/// definition). The base algorithm will omit shadowed paths (ie. those -/// discarded by higher precedence edges) from the results, but there are other -/// circumstances when many definitions may be found: -/// -/// 1. Destructuring imports (with or without aliases): these are -/// represented in the graph as intermediate definition nodes along the -/// path to the actual definition; hence why this function will return -/// the longest path available. -/// -/// 2. Virtual methods: a reference should find valid paths to all available -/// definitions in a class hierarchy. -/// -pub(crate) struct Resolver<'a, KT: KindTypes + 'static> { - owner: &'a BindingGraph, - reference: Reference<'a, KT>, - partials: PartialPaths, - results: Vec>, - options: ResolveOptions, -} - -#[derive(Copy, Clone, Eq, PartialEq)] -pub(crate) enum ResolveOptions { - Full, - NonRecursive, -} - -/// Candidates for the forward stitching resolution process. This will inject -/// edges to the the given extensions scopes at extension hook nodes when asked -/// for forward candidates (ie. `get_forward_candidates`) by the resolution -/// algorithm. Other than that, it's exactly the same as `GraphEdgeCandidates`. -struct ResolverCandidates<'a, KT: KindTypes + 'static> { - owner: &'a BindingGraph, - partials: &'a mut PartialPaths, - file: Option, - edges: GraphEdges, - extensions: &'a [GraphHandle], -} - -impl<'a, KT: KindTypes + 'static> ResolverCandidates<'a, KT> { - pub fn new( - owner: &'a BindingGraph, - partials: &'a mut PartialPaths, - file: Option, - extensions: &'a [GraphHandle], - ) -> Self { - Self { - owner, - partials, - file, - edges: GraphEdges, - extensions, - } - } -} - -impl ForwardCandidates - for ResolverCandidates<'_, KT> -{ - fn get_forward_candidates(&mut self, path: &PartialPath, result: &mut R) - where - R: std::iter::Extend, - { - let node = path.end_node; - result.extend(self.owner.stack_graph.outgoing_edges(node).filter(|e| { - self.file - .map_or(true, |file| self.owner.stack_graph[e.sink].is_in_file(file)) - })); - - if self.owner.is_extension_hook(node) { - // Inject edges from the extension hook node to each extension scope - let mut extension_edges = Vec::new(); - for extension in self.extensions { - extension_edges.push(Edge { - source: node, - sink: *extension, - precedence: 0, - }); - } - result.extend(extension_edges); - } - } - - fn get_joining_candidate_degree(&self, path: &PartialPath) -> Degree { - self.owner.stack_graph.incoming_edge_degree(path.end_node) - } - - fn get_graph_partials_and_db(&mut self) -> (&StackGraph, &mut PartialPaths, &GraphEdges) { - (&self.owner.stack_graph, self.partials, &self.edges) - } -} - -impl<'a, KT: KindTypes + 'static> Resolver<'a, KT> { - pub fn build_for(reference: &Reference<'a, KT>, options: ResolveOptions) -> Self { - let mut resolver = Self { - owner: reference.owner, - reference: reference.clone(), - partials: PartialPaths::new(), - results: Vec::new(), - options, - }; - resolver.resolve(); - resolver - } - - fn resolve(&mut self) { - let mut reference_paths = Vec::new(); - if self.options == ResolveOptions::Full { - let ref_parents = self.reference.resolve_parents(); - let mut extensions = HashSet::new(); - for parent in &ref_parents { - if let Some(extension_scope) = parent.get_extension_scope() { - extensions.insert(extension_scope); - } - - if parent.inherit_extensions() { - #[allow(clippy::mutable_key_type)] - let grand_parents = Self::resolve_parents_all(parent.clone()); - for grand_parent in grand_parents.values().flatten() { - if let Some(extension_scope) = grand_parent.get_extension_scope() { - extensions.insert(extension_scope); - } - } - } - } - let extensions = extensions.drain().collect::>(); - - ForwardPartialPathStitcher::find_all_complete_partial_paths( - &mut ResolverCandidates::new(self.owner, &mut self.partials, None, &extensions), - once(self.reference.handle), - StitcherConfig::default(), - &stack_graphs::NoCancellation, - |_graph, _paths, path| { - reference_paths.push(path.clone()); - }, - ) - .expect("Should never be cancelled"); - } else { - ForwardPartialPathStitcher::find_all_complete_partial_paths( - &mut GraphEdgeCandidates::new(&self.owner.stack_graph, &mut self.partials, None), - once(self.reference.handle), - StitcherConfig::default(), - &stack_graphs::NoCancellation, - |_graph, _paths, path| { - reference_paths.push(path.clone()); - }, - ) - .expect("Should never be cancelled"); - }; - - let mut added_nodes = HashSet::new(); - for reference_path in &reference_paths { - let end_node = reference_path.end_node; - - // There may be duplicate ending nodes with different - // post-conditions in the scope stack, but we only care about the - // definition itself. Hence we need to check for uniqueness. - if !added_nodes.contains(&end_node) - && reference_paths - .iter() - .all(|other| !other.shadows(&mut self.partials, reference_path)) - { - self.results.push( - self.owner - .to_definition(end_node) - .expect("path to end in a definition node"), - ); - added_nodes.insert(end_node); - } - } - } - - pub fn all(self) -> Vec> { - self.results - } - - #[allow(clippy::mutable_key_type)] - fn resolve_parents_all( - context: Definition<'a, KT>, - ) -> HashMap, Vec>> { - let mut results = HashMap::new(); - let mut resolve_queue = Vec::new(); - resolve_queue.push(context); - while let Some(current) = resolve_queue.pop() { - let current_parents = current.resolve_parents(); - for current_parent in ¤t_parents { - if !results.contains_key(current_parent) { - resolve_queue.push(current_parent.clone()); - } - } - results.insert(current, current_parents); - } - results - } -} diff --git a/crates/metaslang/cst/generated/public_api.txt b/crates/metaslang/cst/generated/public_api.txt index 83370fcc7c..dea44ae643 100644 --- a/crates/metaslang/cst/generated/public_api.txt +++ b/crates/metaslang/cst/generated/public_api.txt @@ -51,6 +51,22 @@ impl core::iter::traits::iterator::Iterator pub type metaslang_cst::cursor::CursorIterator::Item = metaslang_cst::nodes::Edge pub fn metaslang_cst::cursor::CursorIterator::next(&mut self) -> core::option::Option pub mod metaslang_cst::kinds +pub enum metaslang_cst::kinds::NodeKind +pub metaslang_cst::kinds::NodeKind::Nonterminal(::NonterminalKind) +pub metaslang_cst::kinds::NodeKind::Terminal(::TerminalKind) +impl core::clone::Clone for metaslang_cst::kinds::NodeKind where ::NonterminalKind: core::clone::Clone, ::TerminalKind: core::clone::Clone +pub fn metaslang_cst::kinds::NodeKind::clone(&self) -> metaslang_cst::kinds::NodeKind +impl core::cmp::Eq for metaslang_cst::kinds::NodeKind where ::NonterminalKind: core::cmp::Eq, ::TerminalKind: core::cmp::Eq +impl core::cmp::PartialEq for metaslang_cst::kinds::NodeKind where ::NonterminalKind: core::cmp::PartialEq, ::TerminalKind: core::cmp::PartialEq +pub fn metaslang_cst::kinds::NodeKind::eq(&self, other: &metaslang_cst::kinds::NodeKind) -> bool +impl core::fmt::Debug for metaslang_cst::kinds::NodeKind where ::NonterminalKind: core::fmt::Debug, ::TerminalKind: core::fmt::Debug +pub fn metaslang_cst::kinds::NodeKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::marker::Copy for metaslang_cst::kinds::NodeKind where ::NonterminalKind: core::marker::Copy, ::TerminalKind: core::marker::Copy +impl core::convert::From> for &'static str +pub fn &'static str::from(val: metaslang_cst::kinds::NodeKind) -> Self +impl core::fmt::Display for metaslang_cst::kinds::NodeKind +pub fn metaslang_cst::kinds::NodeKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::marker::StructuralPartialEq for metaslang_cst::kinds::NodeKind pub trait metaslang_cst::kinds::BaseKind: core::marker::Sized + core::fmt::Debug + core::marker::Copy + core::cmp::PartialEq + core::cmp::Eq + serde::ser::Serialize pub fn metaslang_cst::kinds::BaseKind::as_static_str(&self) -> &'static str pub fn metaslang_cst::kinds::BaseKind::try_from_str(str: &str) -> core::result::Result @@ -90,7 +106,7 @@ pub fn metaslang_cst::nodes::Node::is_terminal(&self) -> bool pub fn metaslang_cst::nodes::Node::is_terminal_with_kind(&self, kind: ::TerminalKind) -> bool pub fn metaslang_cst::nodes::Node::is_terminal_with_kinds(&self, kinds: &[::TerminalKind]) -> bool pub fn metaslang_cst::nodes::Node::is_trivia(&self) -> bool -pub fn metaslang_cst::nodes::Node::kind(&self) -> metaslang_cst::nodes::NodeKind +pub fn metaslang_cst::nodes::Node::kind(&self) -> metaslang_cst::kinds::NodeKind pub fn metaslang_cst::nodes::Node::nonterminal(kind: ::NonterminalKind, children: alloc::vec::Vec>) -> Self pub fn metaslang_cst::nodes::Node::terminal(kind: ::TerminalKind, text: alloc::string::String) -> Self pub fn metaslang_cst::nodes::Node::text_len(&self) -> metaslang_cst::text_index::TextIndex @@ -109,22 +125,6 @@ pub fn metaslang_cst::nodes::Node::from(terminal: alloc::rc::Rc core::marker::StructuralPartialEq for metaslang_cst::nodes::Node impl serde::ser::Serialize for metaslang_cst::nodes::Node where T: serde::ser::Serialize + metaslang_cst::kinds::KindTypes pub fn metaslang_cst::nodes::Node::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer -pub enum metaslang_cst::nodes::NodeKind -pub metaslang_cst::nodes::NodeKind::Nonterminal(::NonterminalKind) -pub metaslang_cst::nodes::NodeKind::Terminal(::TerminalKind) -impl core::clone::Clone for metaslang_cst::nodes::NodeKind where ::NonterminalKind: core::clone::Clone, ::TerminalKind: core::clone::Clone -pub fn metaslang_cst::nodes::NodeKind::clone(&self) -> metaslang_cst::nodes::NodeKind -impl core::cmp::Eq for metaslang_cst::nodes::NodeKind where ::NonterminalKind: core::cmp::Eq, ::TerminalKind: core::cmp::Eq -impl core::cmp::PartialEq for metaslang_cst::nodes::NodeKind where ::NonterminalKind: core::cmp::PartialEq, ::TerminalKind: core::cmp::PartialEq -pub fn metaslang_cst::nodes::NodeKind::eq(&self, other: &metaslang_cst::nodes::NodeKind) -> bool -impl core::fmt::Debug for metaslang_cst::nodes::NodeKind where ::NonterminalKind: core::fmt::Debug, ::TerminalKind: core::fmt::Debug -pub fn metaslang_cst::nodes::NodeKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Copy for metaslang_cst::nodes::NodeKind where ::NonterminalKind: core::marker::Copy, ::TerminalKind: core::marker::Copy -impl core::convert::From> for &'static str -pub fn &'static str::from(val: metaslang_cst::nodes::NodeKind) -> Self -impl core::fmt::Display for metaslang_cst::nodes::NodeKind -pub fn metaslang_cst::nodes::NodeKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::StructuralPartialEq for metaslang_cst::nodes::NodeKind pub struct metaslang_cst::nodes::Edge pub metaslang_cst::nodes::Edge::label: core::option::Option<::EdgeLabel> pub metaslang_cst::nodes::Edge::node: metaslang_cst::nodes::Node diff --git a/crates/metaslang/cst/src/kinds.rs b/crates/metaslang/cst/src/kinds.rs index a9127773c5..efd0ab01d4 100644 --- a/crates/metaslang/cst/src/kinds.rs +++ b/crates/metaslang/cst/src/kinds.rs @@ -48,3 +48,31 @@ pub trait KindTypes: std::fmt::Debug + Clone + PartialEq { type TerminalKind: TerminalKindExtensions; type EdgeLabel: EdgeLabelExtensions; } + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum NodeKind { + Nonterminal(T::NonterminalKind), + Terminal(T::TerminalKind), +} + +impl From> for &'static str { + fn from(val: NodeKind) -> Self { + match val { + NodeKind::Nonterminal(t) => t.as_static_str(), + NodeKind::Terminal(t) => t.as_static_str(), + } + } +} + +impl std::fmt::Display for NodeKind { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + NodeKind::Nonterminal(t) => { + write!(f, "{}", t.as_static_str()) + } + NodeKind::Terminal(t) => { + write!(f, "{}", t.as_static_str()) + } + } + } +} diff --git a/crates/metaslang/cst/src/nodes.rs b/crates/metaslang/cst/src/nodes.rs index 8795b70a9e..90214d6a06 100644 --- a/crates/metaslang/cst/src/nodes.rs +++ b/crates/metaslang/cst/src/nodes.rs @@ -3,37 +3,9 @@ use std::rc::Rc; use serde::Serialize; use crate::cursor::{Cursor, CursorIterator}; -use crate::kinds::{BaseKind, KindTypes, TerminalKindExtensions}; +use crate::kinds::{KindTypes, NodeKind, TerminalKindExtensions}; use crate::text_index::TextIndex; -#[derive(Debug, Copy, Clone, PartialEq, Eq)] -pub enum NodeKind { - Nonterminal(T::NonterminalKind), - Terminal(T::TerminalKind), -} - -impl From> for &'static str { - fn from(val: NodeKind) -> Self { - match val { - NodeKind::Nonterminal(t) => t.as_static_str(), - NodeKind::Terminal(t) => t.as_static_str(), - } - } -} - -impl std::fmt::Display for NodeKind { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - NodeKind::Nonterminal(t) => { - write!(f, "{}", t.as_static_str()) - } - NodeKind::Terminal(t) => { - write!(f, "{}", t.as_static_str()) - } - } - } -} - #[derive(Clone, Debug, PartialEq, Eq, Serialize)] pub struct TerminalNode { pub kind: T::TerminalKind, diff --git a/crates/metaslang/cst/src/query/engine.rs b/crates/metaslang/cst/src/query/engine.rs index b758f438c5..a49681ee7c 100644 --- a/crates/metaslang/cst/src/query/engine.rs +++ b/crates/metaslang/cst/src/query/engine.rs @@ -7,8 +7,7 @@ use super::model::{ ASTNode, AlternativesASTNode, CaptureASTNode, NodeMatchASTNode, NodeSelector, OneOrMoreASTNode, OptionalASTNode, Query, SequenceASTNode, }; -use crate::kinds::{KindTypes, TerminalKindExtensions}; -use crate::nodes::NodeKind; +use crate::kinds::{KindTypes, NodeKind, TerminalKindExtensions}; use crate::query::CaptureQuantifier; impl Cursor { diff --git a/crates/metaslang/cst/src/query/model.rs b/crates/metaslang/cst/src/query/model.rs index 87da193653..c97a40b19a 100644 --- a/crates/metaslang/cst/src/query/model.rs +++ b/crates/metaslang/cst/src/query/model.rs @@ -2,8 +2,7 @@ use std::collections::BTreeMap; use std::fmt; use std::rc::Rc; -use crate::kinds::{BaseKind, KindTypes}; -use crate::nodes::NodeKind; +use crate::kinds::{BaseKind, KindTypes, NodeKind}; use crate::query::{CaptureQuantifier, QueryError}; #[derive(Clone, Debug)] diff --git a/crates/metaslang/cst/src/query/parser.rs b/crates/metaslang/cst/src/query/parser.rs index 300e985f48..e8460eb013 100644 --- a/crates/metaslang/cst/src/query/parser.rs +++ b/crates/metaslang/cst/src/query/parser.rs @@ -17,8 +17,7 @@ use super::model::{ ASTNode, AlternativesASTNode, CaptureASTNode, NodeMatchASTNode, NodeSelector, OneOrMoreASTNode, OptionalASTNode, SequenceASTNode, }; -use crate::kinds::{BaseKind, KindTypes, TerminalKindExtensions}; -use crate::nodes::NodeKind; +use crate::kinds::{BaseKind, KindTypes, NodeKind, TerminalKindExtensions}; use crate::text_index::TextIndex; // ---------------------------------------------------------------------------- diff --git a/crates/solidity/inputs/language/bindings/rules.msgb b/crates/solidity/inputs/language/bindings/rules.msgb index 9139aa190f..eeb5a00bc1 100644 --- a/crates/solidity/inputs/language/bindings/rules.msgb +++ b/crates/solidity/inputs/language/bindings/rules.msgb @@ -71,6 +71,7 @@ inherit .star_extension ; This is used to indicate the resolution algorithm that here's where it ; should inject any possible extension scopes attr (@source_unit.lexical_scope) extension_hook + attr (@source_unit.lexical_scope) is_endpoint ; Provide a default star extension sink node that gets inherited. This is ; connected to from expressions, and those can potentially happen anywhere. @@ -342,6 +343,7 @@ inherit .star_extension attr (@contract.def) definiens_node = @contract ; The .extensions node is where `using` directives will hook the definitions attr (@contract.def) extension_scope = @contract.extensions + attr (@contract.extensions) is_exported edge @contract.lexical_scope -> @contract.instance attr (@contract.lexical_scope -> @contract.instance) precedence = 1 @@ -408,6 +410,7 @@ inherit .star_extension attr (push_name) push_symbol = (source-text @name) node hook attr (hook) extension_hook + attr (hook) is_endpoint edge call -> push_typeof edge push_typeof -> push_name @@ -654,6 +657,7 @@ inherit .star_extension edge push_typeof -> push_name node hook attr (hook) extension_hook + attr (hook) is_endpoint edge push_name -> hook ; edge push_name -> JUMP_TO_SCOPE_NODE @@ -730,6 +734,7 @@ inherit .star_extension attr (@library.def) definiens_node = @library ; The .extensions node is where `using` directives will hook the definitions attr (@library.def) extension_scope = @library.extensions + attr (@library.extensions) is_exported edge @library.lexical_scope -> @library.ns diff --git a/crates/solidity/outputs/cargo/crate/generated/public_api.txt b/crates/solidity/outputs/cargo/crate/generated/public_api.txt index 48a9440e5c..ab2e8d7acd 100644 --- a/crates/solidity/outputs/cargo/crate/generated/public_api.txt +++ b/crates/solidity/outputs/cargo/crate/generated/public_api.txt @@ -16,13 +16,14 @@ impl core::fmt::Debug for slang_solidity::bindings::BindingGraphInitializationEr pub fn slang_solidity::bindings::BindingGraphInitializationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::fmt::Display for slang_solidity::bindings::BindingGraphInitializationError pub fn slang_solidity::bindings::BindingGraphInitializationError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -pub fn slang_solidity::bindings::create_with_resolver(version: semver::Version, resolver: alloc::rc::Rc>) -> core::result::Result +pub fn slang_solidity::bindings::create_with_resolver(version: semver::Version, resolver: alloc::rc::Rc>) -> core::result::Result pub fn slang_solidity::bindings::get_binding_rules() -> &'static str -pub type slang_solidity::bindings::BindingGraph = metaslang_bindings::BindingGraph -pub type slang_solidity::bindings::BindingLocation = metaslang_bindings::location::BindingLocation -pub type slang_solidity::bindings::Definition<'a> = metaslang_bindings::Definition<'a, slang_solidity::cst::KindTypes> -pub type slang_solidity::bindings::Reference<'a> = metaslang_bindings::Reference<'a, slang_solidity::cst::KindTypes> -pub type slang_solidity::bindings::UserFileLocation = metaslang_bindings::location::UserFileLocation +pub type slang_solidity::bindings::BindingGraph = metaslang_bindings::graph::BindingGraph +pub type slang_solidity::bindings::BindingGraphBuilder = metaslang_bindings::builder::BindingGraphBuilder +pub type slang_solidity::bindings::BindingLocation = metaslang_bindings::graph::location::BindingLocation +pub type slang_solidity::bindings::Definition = metaslang_bindings::graph::definition::Definition +pub type slang_solidity::bindings::Reference = metaslang_bindings::graph::reference::Reference +pub type slang_solidity::bindings::UserFileLocation = metaslang_bindings::graph::location::UserFileLocation pub mod slang_solidity::compilation pub struct slang_solidity::compilation::AddFileResponse pub slang_solidity::compilation::AddFileResponse::import_paths: alloc::vec::Vec @@ -47,6 +48,7 @@ pub fn slang_solidity::compilation::InternalCompilationBuilder::create(language_ pub fn slang_solidity::compilation::InternalCompilationBuilder::resolve_import(&mut self, source_file_id: &str, import_path: &slang_solidity::cst::Cursor, destination_file_id: alloc::string::String) -> core::result::Result<(), ResolveImportError> pub mod slang_solidity::cst pub use slang_solidity::cst::EdgeLabelExtensions +pub use slang_solidity::cst::NodeKind pub use slang_solidity::cst::NonterminalKindExtensions pub use slang_solidity::cst::QueryError pub use slang_solidity::cst::TerminalKindExtensions diff --git a/crates/solidity/outputs/cargo/crate/src/extensions/bindings/mod.rs b/crates/solidity/outputs/cargo/crate/src/extensions/bindings/mod.rs index b3ec4aa052..90b69796da 100644 --- a/crates/solidity/outputs/cargo/crate/src/extensions/bindings/mod.rs +++ b/crates/solidity/outputs/cargo/crate/src/extensions/bindings/mod.rs @@ -4,12 +4,12 @@ use metaslang_cst::text_index::TextIndex; use semver::Version; use crate::bindings::built_ins::get_built_ins_contents; -use crate::bindings::BindingGraph; +use crate::bindings::BindingGraphBuilder; use crate::cst::{Edge, Node, NonterminalNode, TerminalKind, TerminalNode}; use crate::parser::{Parser, ParserInitializationError}; pub fn add_built_ins( - binding_graph: &mut BindingGraph, + builder: &mut BindingGraphBuilder, version: Version, ) -> Result<(), ParserInitializationError> { let source = get_built_ins_contents(&version); @@ -18,7 +18,7 @@ pub fn add_built_ins( let built_ins_cursor = transform(parse_output.tree()).cursor_with_offset(TextIndex::ZERO); - binding_graph.add_system_file("built_ins.sol", built_ins_cursor); + builder.add_system_file("built_ins.sol", built_ins_cursor); Ok(()) } diff --git a/crates/solidity/outputs/cargo/crate/src/generated/bindings/generated/binding_rules.rs b/crates/solidity/outputs/cargo/crate/src/generated/bindings/generated/binding_rules.rs index 7712ef9336..af5af31975 100644 --- a/crates/solidity/outputs/cargo/crate/src/generated/bindings/generated/binding_rules.rs +++ b/crates/solidity/outputs/cargo/crate/src/generated/bindings/generated/binding_rules.rs @@ -76,6 +76,7 @@ inherit .star_extension ; This is used to indicate the resolution algorithm that here's where it ; should inject any possible extension scopes attr (@source_unit.lexical_scope) extension_hook + attr (@source_unit.lexical_scope) is_endpoint ; Provide a default star extension sink node that gets inherited. This is ; connected to from expressions, and those can potentially happen anywhere. @@ -347,6 +348,7 @@ inherit .star_extension attr (@contract.def) definiens_node = @contract ; The .extensions node is where `using` directives will hook the definitions attr (@contract.def) extension_scope = @contract.extensions + attr (@contract.extensions) is_exported edge @contract.lexical_scope -> @contract.instance attr (@contract.lexical_scope -> @contract.instance) precedence = 1 @@ -413,6 +415,7 @@ inherit .star_extension attr (push_name) push_symbol = (source-text @name) node hook attr (hook) extension_hook + attr (hook) is_endpoint edge call -> push_typeof edge push_typeof -> push_name @@ -659,6 +662,7 @@ inherit .star_extension edge push_typeof -> push_name node hook attr (hook) extension_hook + attr (hook) is_endpoint edge push_name -> hook ; edge push_name -> JUMP_TO_SCOPE_NODE @@ -735,6 +739,7 @@ inherit .star_extension attr (@library.def) definiens_node = @library ; The .extensions node is where `using` directives will hook the definitions attr (@library.def) extension_scope = @library.extensions + attr (@library.extensions) is_exported edge @library.lexical_scope -> @library.ns diff --git a/crates/solidity/outputs/cargo/crate/src/generated/bindings/mod.rs b/crates/solidity/outputs/cargo/crate/src/generated/bindings/mod.rs index 7803930461..1bca6fa67e 100644 --- a/crates/solidity/outputs/cargo/crate/src/generated/bindings/mod.rs +++ b/crates/solidity/outputs/cargo/crate/src/generated/bindings/mod.rs @@ -12,9 +12,10 @@ use semver::Version; use crate::cst::KindTypes; +pub type BindingGraphBuilder = metaslang_bindings::BindingGraphBuilder; pub type BindingGraph = metaslang_bindings::BindingGraph; -pub type Definition<'a> = metaslang_bindings::Definition<'a, KindTypes>; -pub type Reference<'a> = metaslang_bindings::Reference<'a, KindTypes>; +pub type Definition = metaslang_bindings::Definition; +pub type Reference = metaslang_bindings::Reference; pub type BindingLocation = metaslang_bindings::BindingLocation; pub type UserFileLocation = metaslang_bindings::UserFileLocation; @@ -31,8 +32,8 @@ pub enum BindingGraphInitializationError { pub fn create_with_resolver( version: Version, resolver: Rc>, -) -> Result { - let mut binding_graph = BindingGraph::create( +) -> Result { + let mut binding_graph = BindingGraphBuilder::create( version.clone(), binding_rules::BINDING_RULES_SOURCE, resolver, diff --git a/crates/solidity/outputs/cargo/crate/src/generated/compilation/unit.rs b/crates/solidity/outputs/cargo/crate/src/generated/compilation/unit.rs index a15100e4df..4e92751737 100644 --- a/crates/solidity/outputs/cargo/crate/src/generated/compilation/unit.rs +++ b/crates/solidity/outputs/cargo/crate/src/generated/compilation/unit.rs @@ -45,14 +45,14 @@ impl CompilationUnit { files: self.files.clone(), }; - let mut binding_graph = + let mut builder = create_with_resolver(self.language_version.clone(), Rc::new(resolver))?; for (id, file) in &self.files { - binding_graph.add_user_file(id, file.create_tree_cursor()); + builder.add_user_file(id, file.create_tree_cursor()); } - Ok(Rc::new(binding_graph)) + Ok(builder.build()) }) } } diff --git a/crates/solidity/outputs/cargo/crate/src/generated/cst/mod.rs b/crates/solidity/outputs/cargo/crate/src/generated/cst/mod.rs index f81de2d58a..a4dd3ebbd0 100644 --- a/crates/solidity/outputs/cargo/crate/src/generated/cst/mod.rs +++ b/crates/solidity/outputs/cargo/crate/src/generated/cst/mod.rs @@ -12,7 +12,7 @@ mod terminal_kind; pub use edge_label::EdgeLabel; pub(crate) use lexical_context::{IsLexicalContext, LexicalContext, LexicalContextType}; pub use metaslang_cst::kinds::{ - EdgeLabelExtensions, NonterminalKindExtensions, TerminalKindExtensions, + EdgeLabelExtensions, NodeKind, NonterminalKindExtensions, TerminalKindExtensions, }; pub use nonterminal_kind::NonterminalKind; pub use terminal_kind::TerminalKind; diff --git a/crates/solidity/outputs/cargo/tests/src/bindings_output/renderer.rs b/crates/solidity/outputs/cargo/tests/src/bindings_output/renderer.rs index ae170b2bdf..92711989d2 100644 --- a/crates/solidity/outputs/cargo/tests/src/bindings_output/renderer.rs +++ b/crates/solidity/outputs/cargo/tests/src/bindings_output/renderer.rs @@ -1,10 +1,11 @@ use std::iter::once; use std::ops::Range; +use std::rc::Rc; use anyhow::Result; use ariadne::{Color, Config, FnCache, Label, Report, ReportBuilder, ReportKind, Source}; use slang_solidity::bindings::{BindingGraph, Definition, Reference}; -use slang_solidity::cst::{NonterminalKind, Query}; +use slang_solidity::cst::{NonterminalKind, TerminalKind}; use slang_solidity::diagnostic; use super::runner::ParsedPart; @@ -12,7 +13,7 @@ use super::runner::ParsedPart; type ReportSpan<'a> = (&'a str, Range); pub(crate) fn render_bindings( - binding_graph: &BindingGraph, + binding_graph: &Rc, parsed_parts: &[ParsedPart<'_>], ) -> Result<(String, bool)> { let mut buffer: Vec = Vec::new(); @@ -70,8 +71,8 @@ fn write_part_report<'a>( // We collect all non built-in definitions in a vector to be able to identify // them by a numeric index -fn collect_all_definitions(binding_graph: &BindingGraph) -> Vec> { - let mut definitions: Vec> = Vec::new(); +fn collect_all_definitions(binding_graph: &Rc) -> Vec { + let mut definitions: Vec = Vec::new(); for definition in binding_graph.all_definitions() { if definition.get_file().is_user() { definitions.push(definition); @@ -93,7 +94,7 @@ impl ParsedPart<'_> { fn check_bindings_coverage<'a>( part: &'a ParsedPart<'a>, - binding_graph: &'a BindingGraph, + binding_graph: &Rc, ) -> (Report<'a, ReportSpan<'a>>, bool) { let mut all_identifiers_bound = true; let mut builder: ReportBuilder<'_, ReportSpan<'_>> = Report::build( @@ -103,24 +104,27 @@ fn check_bindings_coverage<'a>( ) .with_config(Config::default().with_color(false)); - let query = Query::parse("@identifier ([Identifier] | [YulIdentifier])").unwrap(); - let tree_cursor = part.parse_output.create_tree_cursor(); - for result in tree_cursor.query(vec![query]) { - let identifier_cursor = result.captures.get("identifier").unwrap().first().unwrap(); - let parent = { - let mut parent_cursor = identifier_cursor.spawn(); - parent_cursor.go_to_parent(); - parent_cursor.node() - }; - if parent.is_nonterminal_with_kind(NonterminalKind::ExperimentalFeature) { - // ignore identifiers in `pragma experimental` directives + let mut cursor = part.parse_output.create_tree_cursor(); + + while cursor + .go_to_next_terminal_with_kinds(&[TerminalKind::Identifier, TerminalKind::YulIdentifier]) + { + if matches!( + cursor.ancestors().next(), + Some(ancestor) + // ignore identifiers in `pragma experimental` directives, as they are unbound feature names: + if ancestor.kind == NonterminalKind::ExperimentalFeature || + // TODO(#1213): unbound named parameters in mapping types + ancestor.kind == NonterminalKind::MappingKey + ) { continue; } - if binding_graph.definition_at(identifier_cursor).is_none() - && binding_graph.reference_at(identifier_cursor).is_none() + + if binding_graph.definition_at(&cursor).is_none() + && binding_graph.reference_at(&cursor).is_none() { let range = { - let range = identifier_cursor.text_range(); + let range = cursor.text_range(); let start = part.contents[..range.start.utf8].chars().count(); let end = part.contents[..range.end.utf8].chars().count(); start..end @@ -138,8 +142,8 @@ fn check_bindings_coverage<'a>( fn build_report_for_part<'a>( part: &'a ParsedPart<'a>, - all_definitions: &'a [Definition<'a>], - part_references: impl Iterator> + 'a, + all_definitions: &'a [Definition], + part_references: impl Iterator + 'a, ) -> (Report<'a, ReportSpan<'a>>, bool) { let mut builder: ReportBuilder<'_, ReportSpan<'_>> = Report::build( ReportKind::Custom("References and definitions", Color::Unset), @@ -218,7 +222,7 @@ fn build_report_for_part<'a>( fn build_definiens_report<'a>( part: &'a ParsedPart<'a>, - all_definitions: &'a [Definition<'a>], + all_definitions: &'a [Definition], ) -> Report<'a, ReportSpan<'a>> { let mut builder: ReportBuilder<'_, ReportSpan<'_>> = Report::build(ReportKind::Custom("Definiens", Color::Unset), part.path, 0) diff --git a/crates/solidity/outputs/cargo/tests/src/bindings_output/runner.rs b/crates/solidity/outputs/cargo/tests/src/bindings_output/runner.rs index 218e694e4f..aeee8760b3 100644 --- a/crates/solidity/outputs/cargo/tests/src/bindings_output/runner.rs +++ b/crates/solidity/outputs/cargo/tests/src/bindings_output/runner.rs @@ -44,7 +44,7 @@ pub fn run(group_name: &str, test_name: &str) -> Result<()> { for version in &VERSION_BREAKS { let parser = Parser::create(version.clone())?; - let mut binding_graph = + let mut builder = bindings::create_with_resolver(version.clone(), Rc::new(TestsPathResolver {}))?; let mut parsed_parts: Vec> = Vec::new(); @@ -55,8 +55,8 @@ pub fn run(group_name: &str, test_name: &str) -> Result<()> { } in &multi_part.parts { let parse_output = parser.parse(Parser::ROOT_KIND, contents); - let graph = binding_graph - .add_user_file_returning_graph(path, parse_output.create_tree_cursor()); + let graph = + builder.add_user_file_returning_graph(path, parse_output.create_tree_cursor()); parsed_parts.push(ParsedPart { path, contents, @@ -65,6 +65,7 @@ pub fn run(group_name: &str, test_name: &str) -> Result<()> { }); } + let binding_graph = builder.build(); let (bindings_output, all_resolved) = render_bindings(&binding_graph, &parsed_parts)?; let parse_success = parsed_parts.iter().all(|part| part.parse_output.is_valid()); diff --git a/crates/solidity/outputs/cargo/wasm/src/generated/wrappers/bindings/mod.rs b/crates/solidity/outputs/cargo/wasm/src/generated/wrappers/bindings/mod.rs index 6163cf964f..044ca3d6eb 100644 --- a/crates/solidity/outputs/cargo/wasm/src/generated/wrappers/bindings/mod.rs +++ b/crates/solidity/outputs/cargo/wasm/src/generated/wrappers/bindings/mod.rs @@ -14,52 +14,8 @@ mod ffi { mod rust { pub use crate::rust_crate::bindings::{ - BindingGraph, BindingLocation, BuiltInLocation, UserFileLocation, + BindingGraph, BindingLocation, BuiltInLocation, Definition, Reference, UserFileLocation, }; - - /// TODO: This is a work-around for the fact that `metaslang_bindings` internals (handles, locators, etc...) are exposed. - /// We should clean this when we finally publish `__experimental_bindings_api`. - /// That means removing the types below, and using the original types instead. - #[derive(Debug, Clone)] - pub struct Definition { - pub id: usize, - pub name_location: BindingLocation, - pub definiens_location: BindingLocation, - } - - impl From> for Definition { - fn from(definition: crate::rust_crate::bindings::Definition<'_>) -> Self { - Self { - id: definition.id(), - name_location: definition.name_location(), - definiens_location: definition.definiens_location(), - } - } - } - - /// TODO: This is a work-around for the fact that `metaslang_bindings` internals (handles, locators, etc...) are exposed. - /// We should clean this when we finally publish `__experimental_bindings_api`. - /// That means removing the types below, and using the original types instead. - #[derive(Debug, Clone)] - pub struct Reference { - pub id: usize, - pub location: BindingLocation, - pub definitions: Vec, - } - - impl From> for Reference { - fn from(reference: crate::rust_crate::bindings::Reference<'_>) -> Self { - Self { - id: reference.id(), - location: reference.location(), - definitions: reference - .definitions() - .into_iter() - .map(Into::into) - .collect(), - } - } - } } impl ffi::Guest for crate::wasm_crate::World { @@ -102,15 +58,15 @@ define_rc_wrapper! { BindingGraph { define_wrapper! { Definition { fn id(&self) -> u32 { - self._borrow_ffi().id.try_into().unwrap() + self._borrow_ffi().id().try_into().unwrap() } fn name_location(&self) -> ffi::BindingLocation { - self._borrow_ffi().name_location.clone()._into_ffi() + self._borrow_ffi().name_location()._into_ffi() } fn definiens_location(&self) -> ffi::BindingLocation { - self._borrow_ffi().definiens_location.clone()._into_ffi() + self._borrow_ffi().definiens_location()._into_ffi() } } } @@ -122,15 +78,15 @@ define_wrapper! { Definition { define_wrapper! { Reference { fn id(&self) -> u32 { - self._borrow_ffi().id.try_into().unwrap() + self._borrow_ffi().id().try_into().unwrap() } fn location(&self) -> ffi::BindingLocation { - self._borrow_ffi().location.clone()._into_ffi() + self._borrow_ffi().location().clone()._into_ffi() } fn definitions(&self) -> Vec { - self._borrow_ffi().definitions.iter().cloned().map(IntoFFI::_into_ffi).collect() + self._borrow_ffi().definitions().iter().cloned().map(IntoFFI::_into_ffi).collect() } } } diff --git a/crates/solidity/testing/perf/benches/iai/main.rs b/crates/solidity/testing/perf/benches/iai/main.rs index e9216a4f29..f36600ff96 100644 --- a/crates/solidity/testing/perf/benches/iai/main.rs +++ b/crates/solidity/testing/perf/benches/iai/main.rs @@ -7,23 +7,14 @@ use iai_callgrind::{ library_benchmark, library_benchmark_group, main, Direction, FlamegraphConfig, LibraryBenchmarkConfig, Tool, ValgrindTool, }; -use slang_solidity::bindings::BindingGraph; use solidity_testing_perf::dataset::SourceFile; -use solidity_testing_perf::tests::definitions::Dependencies; +use solidity_testing_perf::tests::bindings_resolve::BuiltBindingGraph; use solidity_testing_perf::tests::parser::ParsedFile; mod __dependencies_used_in_lib__ { - use {infra_utils as _, metaslang_bindings as _, semver as _}; + use {infra_utils as _, metaslang_bindings as _, semver as _, slang_solidity as _}; } -macro_rules! define_benchmark { - ($name:ident) => { - #[library_benchmark] - fn $name() { - black_box(solidity_testing_perf::tests::$name::run()); - } - }; -} macro_rules! define_payload_benchmark { ($name:ident, $payload:ty) => { #[library_benchmark(setup = solidity_testing_perf::tests::$name::setup)] @@ -43,15 +34,14 @@ macro_rules! define_payload_benchmark { define_payload_benchmark!(parser, Vec); define_payload_benchmark!(cursor, Vec); define_payload_benchmark!(query, Vec); -define_benchmark!(init_bindings); -define_payload_benchmark!(definitions, Dependencies); -define_payload_benchmark!(references, BindingGraph); +define_payload_benchmark!(bindings_build, Vec); +define_payload_benchmark!(bindings_resolve, BuiltBindingGraph); library_benchmark_group!( name = benchmarks; // __SLANG_INFRA_BENCHMARKS_LIST__ (keep in sync) - benchmarks = parser, cursor, query, init_bindings, definitions, references + benchmarks = parser, cursor, query, bindings_build, bindings_resolve, ); main!( diff --git a/crates/solidity/testing/perf/src/lib.rs b/crates/solidity/testing/perf/src/lib.rs index 0b25500b67..8b58eabad1 100644 --- a/crates/solidity/testing/perf/src/lib.rs +++ b/crates/solidity/testing/perf/src/lib.rs @@ -11,14 +11,6 @@ mod __dependencies_used_in_benches__ { #[cfg(test)] mod unit_tests { - macro_rules! define_test { - ($name:ident) => { - #[test] - fn $name() { - crate::tests::$name::run(); - } - }; - } macro_rules! define_payload_test { ($name:ident) => { #[test] @@ -35,7 +27,6 @@ mod unit_tests { define_payload_test!(parser); define_payload_test!(cursor); define_payload_test!(query); - define_test!(init_bindings); - define_payload_test!(definitions); - define_payload_test!(references); + define_payload_test!(bindings_build); + define_payload_test!(bindings_resolve); } diff --git a/crates/solidity/testing/perf/src/tests/bindings_build.rs b/crates/solidity/testing/perf/src/tests/bindings_build.rs new file mode 100644 index 0000000000..35a95a963f --- /dev/null +++ b/crates/solidity/testing/perf/src/tests/bindings_build.rs @@ -0,0 +1,40 @@ +use std::rc::Rc; + +use infra_utils::paths::PathExtensions; +use metaslang_bindings::PathResolver; +use slang_solidity::bindings::{create_with_resolver, BindingGraph}; +use slang_solidity::cst::{Cursor, KindTypes}; + +use crate::dataset::SOLC_VERSION; +use crate::tests::parser::ParsedFile; + +pub fn setup() -> Vec { + super::parser::run(super::parser::setup()) +} + +pub fn run(files: Vec) -> Rc { + let mut bindings_graph_builder = + create_with_resolver(SOLC_VERSION, Rc::new(Resolver {})).unwrap(); + + for file in files { + bindings_graph_builder.add_user_file( + file.path.unwrap_str(), + file.parse_output.create_tree_cursor(), + ); + } + + bindings_graph_builder.build() +} + +struct Resolver; + +impl PathResolver for Resolver { + fn resolve_path(&self, _context_path: &str, path_to_resolve: &Cursor) -> Option { + let path = path_to_resolve.node().unparse(); + let path = path + .strip_prefix(|c| matches!(c, '"' | '\''))? + .strip_suffix(|c| matches!(c, '"' | '\''))?; + + Some(path.to_owned()) + } +} diff --git a/crates/solidity/testing/perf/src/tests/bindings_resolve.rs b/crates/solidity/testing/perf/src/tests/bindings_resolve.rs new file mode 100644 index 0000000000..ec84c6c1dd --- /dev/null +++ b/crates/solidity/testing/perf/src/tests/bindings_resolve.rs @@ -0,0 +1,61 @@ +use std::rc::Rc; + +use infra_utils::paths::PathExtensions; +use slang_solidity::bindings::BindingGraph; +use slang_solidity::cst::{NonterminalKind, TerminalKind}; + +use crate::tests::parser::ParsedFile; + +pub struct BuiltBindingGraph { + files: Vec, + binding_graph: Rc, +} + +pub fn setup() -> BuiltBindingGraph { + let files = super::parser::run(super::parser::setup()); + let binding_graph = super::bindings_build::run(files.clone()); + + BuiltBindingGraph { + files, + binding_graph, + } +} + +pub fn run(dependencies: BuiltBindingGraph) { + let BuiltBindingGraph { + files, + binding_graph, + } = dependencies; + + for file in files { + let mut cursor = file.parse_output.create_tree_cursor(); + + while cursor.go_to_next_terminal_with_kinds(&[ + TerminalKind::Identifier, + TerminalKind::YulIdentifier, + ]) { + if matches!( + cursor.ancestors().next(), + Some(ancestor) + // ignore identifiers in `pragma experimental` directives, as they are unbound feature names: + if ancestor.kind == NonterminalKind::ExperimentalFeature || + // TODO(#1213): unbound named parameters in mapping types + ancestor.kind == NonterminalKind::MappingKey + ) { + continue; + } + + if binding_graph.definition_at(&cursor).is_none() + && binding_graph.reference_at(&cursor).is_none() + { + panic!( + "Unbound identifier: '{value}' in '{file_path}:{line}:{column}'.", + value = cursor.node().unparse(), + file_path = file.path.unwrap_str(), + line = cursor.text_range().start.line + 1, + column = cursor.text_range().start.column + 1, + ); + } + } + } +} diff --git a/crates/solidity/testing/perf/src/tests/definitions.rs b/crates/solidity/testing/perf/src/tests/definitions.rs deleted file mode 100644 index a41134c328..0000000000 --- a/crates/solidity/testing/perf/src/tests/definitions.rs +++ /dev/null @@ -1,43 +0,0 @@ -use slang_solidity::bindings::BindingGraph; - -use crate::tests::parser::ParsedFile; - -pub struct Dependencies { - pub binding_graph: BindingGraph, - pub files: Vec, -} - -pub fn setup() -> Dependencies { - let binding_graph = super::init_bindings::run(); - let files = super::parser::run(super::parser::setup()); - - Dependencies { - binding_graph, - files, - } -} - -pub fn run(dependencies: Dependencies) -> BindingGraph { - let mut definition_count = 0_usize; - let Dependencies { - mut binding_graph, - files, - } = dependencies; - - for ParsedFile { - path, - contents: _, - parse_output, - } in &files - { - binding_graph.add_user_file(path.to_str().unwrap(), parse_output.create_tree_cursor()); - definition_count += binding_graph - .all_definitions() - .filter(|definition| definition.get_file().is_user()) - .count(); - } - - assert_eq!(definition_count, 2322, "Failed to fetch all definitions"); - - binding_graph -} diff --git a/crates/solidity/testing/perf/src/tests/init_bindings.rs b/crates/solidity/testing/perf/src/tests/init_bindings.rs deleted file mode 100644 index f46ffa186c..0000000000 --- a/crates/solidity/testing/perf/src/tests/init_bindings.rs +++ /dev/null @@ -1,24 +0,0 @@ -use std::rc::Rc; - -use metaslang_bindings::PathResolver; -use slang_solidity::bindings::{create_with_resolver, BindingGraph}; -use slang_solidity::cst::{Cursor, KindTypes}; - -use crate::dataset::SOLC_VERSION; - -pub fn run() -> BindingGraph { - create_with_resolver(SOLC_VERSION, Rc::new(NoOpResolver {})).unwrap() -} - -struct NoOpResolver; - -impl PathResolver for NoOpResolver { - fn resolve_path(&self, _context_path: &str, path_to_resolve: &Cursor) -> Option { - let path = path_to_resolve.node().unparse(); - let path = path - .strip_prefix(|c| matches!(c, '"' | '\''))? - .strip_suffix(|c| matches!(c, '"' | '\''))?; - - Some(path.to_owned()) - } -} diff --git a/crates/solidity/testing/perf/src/tests/mod.rs b/crates/solidity/testing/perf/src/tests/mod.rs index d593675b64..c9a1088461 100644 --- a/crates/solidity/testing/perf/src/tests/mod.rs +++ b/crates/solidity/testing/perf/src/tests/mod.rs @@ -1,6 +1,5 @@ +pub mod bindings_build; +pub mod bindings_resolve; pub mod cursor; -pub mod definitions; -pub mod init_bindings; pub mod parser; pub mod query; -pub mod references; diff --git a/crates/solidity/testing/perf/src/tests/parser.rs b/crates/solidity/testing/perf/src/tests/parser.rs index 6892a0429e..1eecbec387 100644 --- a/crates/solidity/testing/perf/src/tests/parser.rs +++ b/crates/solidity/testing/perf/src/tests/parser.rs @@ -4,6 +4,7 @@ use slang_solidity::parser::{ParseOutput, Parser}; use crate::dataset::{SourceFile, SOLC_VERSION}; +#[derive(Clone)] pub struct ParsedFile { pub path: PathBuf, diff --git a/crates/solidity/testing/perf/src/tests/references.rs b/crates/solidity/testing/perf/src/tests/references.rs deleted file mode 100644 index 9ba38d9f31..0000000000 --- a/crates/solidity/testing/perf/src/tests/references.rs +++ /dev/null @@ -1,32 +0,0 @@ -use slang_solidity::bindings::BindingGraph; - -pub fn setup() -> BindingGraph { - let dependencies = super::definitions::setup(); - - super::definitions::run(dependencies) -} - -pub fn run(binding_graph: BindingGraph) { - let mut reference_count = 0_usize; - let mut resolved_references = 0_usize; - - for reference in binding_graph.all_references() { - if reference.get_file().is_system() { - // skip built-ins - continue; - } - reference_count += 1; - - let definitions = reference.definitions(); - if !definitions.is_empty() { - resolved_references += 1; - } - } - - assert_eq!(reference_count, 1652, "Failed to fetch all references"); - - assert_eq!( - resolved_references, 1490, - "Failed to resolve all references" - ); -} diff --git a/crates/solidity/testing/sanctuary/src/tests.rs b/crates/solidity/testing/sanctuary/src/tests.rs index c02c60b79f..87a59f020f 100644 --- a/crates/solidity/testing/sanctuary/src/tests.rs +++ b/crates/solidity/testing/sanctuary/src/tests.rs @@ -7,9 +7,8 @@ use infra_utils::paths::PathExtensions; use itertools::Itertools; use metaslang_bindings::PathResolver; use semver::Version; -use slang_solidity::bindings; -use slang_solidity::bindings::BindingGraph; -use slang_solidity::cst::{Cursor, KindTypes, NonterminalKind, Query, TextRange}; +use slang_solidity::bindings::{self, BindingGraph}; +use slang_solidity::cst::{Cursor, KindTypes, NonterminalKind, TerminalKind, TextRange}; use slang_solidity::diagnostic::{Diagnostic, Severity}; use slang_solidity::parser::{ParseOutput, Parser}; use slang_solidity::utils::LanguageFacts; @@ -202,27 +201,31 @@ fn run_bindings_check( } } - // Check that all `Identifier` and `YulIdentifier` nodes are bound to either - // a definition or a reference - let query = Query::parse("@identifier ([Identifier] | [YulIdentifier])").unwrap(); - let tree_cursor = output.create_tree_cursor(); - for result in tree_cursor.query(vec![query]) { - let identifier_cursor = result.captures.get("identifier").unwrap().first().unwrap(); - let parent = { - let mut parent_cursor = identifier_cursor.spawn(); - parent_cursor.go_to_parent(); - parent_cursor.node() - }; - if parent.is_nonterminal_with_kind(NonterminalKind::ExperimentalFeature) { - // ignore identifiers in `pragma experimental` directives + // Check that all `Identifier` and `YulIdentifier` nodes are bound to either a definition or a reference: + + let mut cursor = output.create_tree_cursor(); + + while cursor + .go_to_next_terminal_with_kinds(&[TerminalKind::Identifier, TerminalKind::YulIdentifier]) + { + if matches!( + cursor.ancestors().next(), + Some(ancestor) + // ignore identifiers in `pragma experimental` directives, as they are unbound feature names: + if ancestor.kind == NonterminalKind::ExperimentalFeature || + // TODO(#1213): unbound named parameters in mapping types + ancestor.kind == NonterminalKind::MappingKey + ) { continue; } - if binding_graph.definition_at(identifier_cursor).is_none() - && binding_graph.reference_at(identifier_cursor).is_none() + + if binding_graph.definition_at(&cursor).is_none() + && binding_graph.reference_at(&cursor).is_none() { - errors.push(BindingError::UnboundIdentifier(identifier_cursor.clone())); + errors.push(BindingError::UnboundIdentifier(cursor.clone())); } } + Ok(errors) } @@ -230,17 +233,17 @@ fn create_bindings( version: &Version, source_id: &str, output: &ParseOutput, -) -> Result { - let mut binding_graph = bindings::create_with_resolver( +) -> Result> { + let mut builder = bindings::create_with_resolver( version.clone(), Rc::new(SingleFileResolver { source_id: source_id.into(), }), )?; - binding_graph.add_user_file(source_id, output.create_tree_cursor()); + builder.add_user_file(source_id, output.create_tree_cursor()); - Ok(binding_graph) + Ok(builder.build()) } /// The `PathResolver` that always resolves to the given `source_id`. diff --git a/crates/testlang/outputs/cargo/crate/src/extensions/bindings/mod.rs b/crates/testlang/outputs/cargo/crate/src/extensions/bindings/mod.rs index eee8b7880f..c3f95c7400 100644 --- a/crates/testlang/outputs/cargo/crate/src/extensions/bindings/mod.rs +++ b/crates/testlang/outputs/cargo/crate/src/extensions/bindings/mod.rs @@ -1,11 +1,11 @@ use semver::Version; -use crate::bindings::BindingGraph; +use crate::bindings::BindingGraphBuilder; use crate::parser::ParserInitializationError; #[allow(clippy::needless_pass_by_value)] pub fn add_built_ins( - _binding_graph: &mut BindingGraph, + _binding_graph_builder: &mut BindingGraphBuilder, _version: Version, ) -> Result<(), ParserInitializationError> { unreachable!("Built-ins are Solidity-specific") diff --git a/crates/testlang/outputs/cargo/crate/src/generated/bindings/mod.rs b/crates/testlang/outputs/cargo/crate/src/generated/bindings/mod.rs index 7803930461..1bca6fa67e 100644 --- a/crates/testlang/outputs/cargo/crate/src/generated/bindings/mod.rs +++ b/crates/testlang/outputs/cargo/crate/src/generated/bindings/mod.rs @@ -12,9 +12,10 @@ use semver::Version; use crate::cst::KindTypes; +pub type BindingGraphBuilder = metaslang_bindings::BindingGraphBuilder; pub type BindingGraph = metaslang_bindings::BindingGraph; -pub type Definition<'a> = metaslang_bindings::Definition<'a, KindTypes>; -pub type Reference<'a> = metaslang_bindings::Reference<'a, KindTypes>; +pub type Definition = metaslang_bindings::Definition; +pub type Reference = metaslang_bindings::Reference; pub type BindingLocation = metaslang_bindings::BindingLocation; pub type UserFileLocation = metaslang_bindings::UserFileLocation; @@ -31,8 +32,8 @@ pub enum BindingGraphInitializationError { pub fn create_with_resolver( version: Version, resolver: Rc>, -) -> Result { - let mut binding_graph = BindingGraph::create( +) -> Result { + let mut binding_graph = BindingGraphBuilder::create( version.clone(), binding_rules::BINDING_RULES_SOURCE, resolver, diff --git a/crates/testlang/outputs/cargo/crate/src/generated/compilation/unit.rs b/crates/testlang/outputs/cargo/crate/src/generated/compilation/unit.rs index a15100e4df..4e92751737 100644 --- a/crates/testlang/outputs/cargo/crate/src/generated/compilation/unit.rs +++ b/crates/testlang/outputs/cargo/crate/src/generated/compilation/unit.rs @@ -45,14 +45,14 @@ impl CompilationUnit { files: self.files.clone(), }; - let mut binding_graph = + let mut builder = create_with_resolver(self.language_version.clone(), Rc::new(resolver))?; for (id, file) in &self.files { - binding_graph.add_user_file(id, file.create_tree_cursor()); + builder.add_user_file(id, file.create_tree_cursor()); } - Ok(Rc::new(binding_graph)) + Ok(builder.build()) }) } } diff --git a/crates/testlang/outputs/cargo/crate/src/generated/cst/mod.rs b/crates/testlang/outputs/cargo/crate/src/generated/cst/mod.rs index f81de2d58a..a4dd3ebbd0 100644 --- a/crates/testlang/outputs/cargo/crate/src/generated/cst/mod.rs +++ b/crates/testlang/outputs/cargo/crate/src/generated/cst/mod.rs @@ -12,7 +12,7 @@ mod terminal_kind; pub use edge_label::EdgeLabel; pub(crate) use lexical_context::{IsLexicalContext, LexicalContext, LexicalContextType}; pub use metaslang_cst::kinds::{ - EdgeLabelExtensions, NonterminalKindExtensions, TerminalKindExtensions, + EdgeLabelExtensions, NodeKind, NonterminalKindExtensions, TerminalKindExtensions, }; pub use nonterminal_kind::NonterminalKind; pub use terminal_kind::TerminalKind; diff --git a/crates/testlang/outputs/cargo/wasm/src/generated/wrappers/bindings/mod.rs b/crates/testlang/outputs/cargo/wasm/src/generated/wrappers/bindings/mod.rs index 6163cf964f..044ca3d6eb 100644 --- a/crates/testlang/outputs/cargo/wasm/src/generated/wrappers/bindings/mod.rs +++ b/crates/testlang/outputs/cargo/wasm/src/generated/wrappers/bindings/mod.rs @@ -14,52 +14,8 @@ mod ffi { mod rust { pub use crate::rust_crate::bindings::{ - BindingGraph, BindingLocation, BuiltInLocation, UserFileLocation, + BindingGraph, BindingLocation, BuiltInLocation, Definition, Reference, UserFileLocation, }; - - /// TODO: This is a work-around for the fact that `metaslang_bindings` internals (handles, locators, etc...) are exposed. - /// We should clean this when we finally publish `__experimental_bindings_api`. - /// That means removing the types below, and using the original types instead. - #[derive(Debug, Clone)] - pub struct Definition { - pub id: usize, - pub name_location: BindingLocation, - pub definiens_location: BindingLocation, - } - - impl From> for Definition { - fn from(definition: crate::rust_crate::bindings::Definition<'_>) -> Self { - Self { - id: definition.id(), - name_location: definition.name_location(), - definiens_location: definition.definiens_location(), - } - } - } - - /// TODO: This is a work-around for the fact that `metaslang_bindings` internals (handles, locators, etc...) are exposed. - /// We should clean this when we finally publish `__experimental_bindings_api`. - /// That means removing the types below, and using the original types instead. - #[derive(Debug, Clone)] - pub struct Reference { - pub id: usize, - pub location: BindingLocation, - pub definitions: Vec, - } - - impl From> for Reference { - fn from(reference: crate::rust_crate::bindings::Reference<'_>) -> Self { - Self { - id: reference.id(), - location: reference.location(), - definitions: reference - .definitions() - .into_iter() - .map(Into::into) - .collect(), - } - } - } } impl ffi::Guest for crate::wasm_crate::World { @@ -102,15 +58,15 @@ define_rc_wrapper! { BindingGraph { define_wrapper! { Definition { fn id(&self) -> u32 { - self._borrow_ffi().id.try_into().unwrap() + self._borrow_ffi().id().try_into().unwrap() } fn name_location(&self) -> ffi::BindingLocation { - self._borrow_ffi().name_location.clone()._into_ffi() + self._borrow_ffi().name_location()._into_ffi() } fn definiens_location(&self) -> ffi::BindingLocation { - self._borrow_ffi().definiens_location.clone()._into_ffi() + self._borrow_ffi().definiens_location()._into_ffi() } } } @@ -122,15 +78,15 @@ define_wrapper! { Definition { define_wrapper! { Reference { fn id(&self) -> u32 { - self._borrow_ffi().id.try_into().unwrap() + self._borrow_ffi().id().try_into().unwrap() } fn location(&self) -> ffi::BindingLocation { - self._borrow_ffi().location.clone()._into_ffi() + self._borrow_ffi().location().clone()._into_ffi() } fn definitions(&self) -> Vec { - self._borrow_ffi().definitions.iter().cloned().map(IntoFFI::_into_ffi).collect() + self._borrow_ffi().definitions().iter().cloned().map(IntoFFI::_into_ffi).collect() } } }