Merge pull request #233 from koto-lang/switch-to-crate-import-granula…

…rity

Switch to using the `crate` import granularity style

core/bytecode/src/chunk.rs

@@ -1,11 +1,9 @@
-use {
-    crate::InstructionReader,
-    koto_memory::Ptr,
-    koto_parser::{ConstantPool, Span},
-    std::{
-        fmt::{self, Write},
-        path::PathBuf,
-    },
+use crate::InstructionReader;
+use koto_memory::Ptr;
+use koto_parser::{ConstantPool, Span};
+use std::{
+    fmt::{self, Write},
+    path::PathBuf,
 };
 
 /// Debug information for a Koto program

core/bytecode/src/compiler.rs

@@ -1,13 +1,11 @@
-use {
-    crate::{DebugInfo, FunctionFlags, Op, TypeId},
-    koto_parser::{
-        AssignTarget, Ast, AstBinaryOp, AstFor, AstIf, AstIndex, AstNode, AstTry, AstUnaryOp,
-        ConstantIndex, Function, ImportItemNode, LookupNode, MapKey, MatchArm, MetaKeyId, Node,
-        Scope, Span, StringNode, SwitchArm,
-    },
-    smallvec::SmallVec,
-    std::{collections::HashSet, error, fmt},
+use crate::{DebugInfo, FunctionFlags, Op, TypeId};
+use koto_parser::{
+    AssignTarget, Ast, AstBinaryOp, AstFor, AstIf, AstIndex, AstNode, AstTry, AstUnaryOp,
+    ConstantIndex, Function, ImportItemNode, LookupNode, MapKey, MatchArm, MetaKeyId, Node, Scope,
+    Span, StringNode, SwitchArm,
 };
+use smallvec::SmallVec;
+use std::{collections::HashSet, error, fmt};
 
 /// The error type used to report errors during compilation
 #[derive(Clone, Debug)]

core/bytecode/src/instruction_reader.rs

@@ -1,9 +1,7 @@
-use {
-    crate::{Chunk, Op},
-    koto_memory::Ptr,
-    koto_parser::{ConstantIndex, MetaKeyId},
-    std::fmt,
-};
+use crate::{Chunk, Op};
+use koto_memory::Ptr;
+use koto_parser::{ConstantIndex, MetaKeyId};
+use std::fmt;
 
 #[derive(Debug)]
 #[repr(u8)]

core/bytecode/src/lib.rs

@@ -9,7 +9,7 @@ mod instruction_reader;
 mod loader;
 mod op;
 
-pub use {
+pub use crate::{
     chunk::{Chunk, DebugInfo},
     compiler::{Compiler, CompilerError, CompilerSettings},
     instruction_reader::{FunctionFlags, Instruction, InstructionReader, TypeId},

core/bytecode/src/loader.rs

@@ -1,11 +1,9 @@
-use {
-    crate::{Chunk, Compiler, CompilerError, CompilerSettings},
-    dunce::canonicalize,
-    koto_memory::Ptr,
-    koto_parser::{format_error_with_excerpt, Parser, ParserError},
-    rustc_hash::FxHasher,
-    std::{collections::HashMap, error, fmt, hash::BuildHasherDefault, path::PathBuf},
-};
+use crate::{Chunk, Compiler, CompilerError, CompilerSettings};
+use dunce::canonicalize;
+use koto_memory::Ptr;
+use koto_parser::{format_error_with_excerpt, Parser, ParserError};
+use rustc_hash::FxHasher;
+use std::{collections::HashMap, error, fmt, hash::BuildHasherDefault, path::PathBuf};
 
 /// Errors that can be returned from [Loader] operations
 #[derive(Clone, Debug)]

core/bytecode/tests/compile_failures.rs

@@ -1,8 +1,6 @@
 mod bytecode {
-    use {
-        koto_bytecode::{Compiler, CompilerSettings},
-        koto_parser::Parser,
-    };
+    use koto_bytecode::{Compiler, CompilerSettings};
+    use koto_parser::Parser;
 
     fn check_compilation_fails(source: &str) {
         match Parser::parse(source) {

core/cli/src/help.rs

@@ -1,4 +1,5 @@
-use {indexmap::IndexMap, std::iter::Peekable};
+use indexmap::IndexMap;
+use std::iter::Peekable;
 
 const HELP_RESULT_STR: &str = "# ➝ ";
 const HELP_INDENT: usize = 2;

core/cli/src/main.rs

@@ -1,12 +1,10 @@
 mod help;
 mod repl;
 
-use {
-    crossterm::tty::IsTty,
-    koto::{bytecode::Chunk, Koto, KotoSettings},
-    repl::{Repl, ReplSettings},
-    std::{fs, io},
-};
+use crossterm::tty::IsTty;
+use koto::{bytecode::Chunk, Koto, KotoSettings};
+use repl::{Repl, ReplSettings};
+use std::{fs, io};
 
 #[cfg(all(jemalloc, not(debug_assertions), not(target_env = "msvc")))]
 #[global_allocator]

core/cli/src/repl.rs

@@ -1,21 +1,19 @@
-use {
-    crate::help::Help,
-    crossterm::{
-        cursor,
-        event::{read, Event, KeyCode, KeyEvent, KeyModifiers},
-        execute, queue, style,
-        terminal::{self, ClearType},
-        tty::IsTty,
-        Result,
-    },
-    koto::{bytecode::Chunk, Koto, KotoSettings},
-    std::{
-        cmp::Ordering,
-        fmt,
-        io::{self, Stdout, Write},
-    },
-    unicode_width::UnicodeWidthChar,
+use crate::help::Help;
+use crossterm::{
+    cursor,
+    event::{read, Event, KeyCode, KeyEvent, KeyModifiers},
+    execute, queue, style,
+    terminal::{self, ClearType},
+    tty::IsTty,
+    Result,
 };
+use koto::{bytecode::Chunk, Koto, KotoSettings};
+use std::{
+    cmp::Ordering,
+    fmt,
+    io::{self, Stdout, Write},
+};
+use unicode_width::UnicodeWidthChar;
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 

core/koto/benches/koto_benchmark.rs

@@ -1,8 +1,6 @@
-use {
-    criterion::{criterion_group, criterion_main, Criterion},
-    koto::Koto,
-    std::{fs::read_to_string, path::PathBuf},
-};
+use criterion::{criterion_group, criterion_main, Criterion};
+use koto::Koto;
+use std::{fs::read_to_string, path::PathBuf};
 
 #[cfg(not(target_env = "msvc"))]
 #[global_allocator]

core/koto/src/koto.rs

@@ -1,10 +1,8 @@
-use {
-    crate::prelude::*,
-    dunce::canonicalize,
-    koto_bytecode::CompilerSettings,
-    koto_runtime::ModuleImportedCallback,
-    std::{error::Error, fmt, path::PathBuf, rc::Rc},
-};
+use crate::prelude::*;
+use dunce::canonicalize;
+use koto_bytecode::CompilerSettings;
+use koto_runtime::ModuleImportedCallback;
+use std::{error::Error, fmt, path::PathBuf, rc::Rc};
 
 /// The error type returned by [Koto] operations
 #[allow(missing_docs)]

core/koto/src/lib.rs

@@ -31,7 +31,7 @@
 mod koto;
 pub mod prelude;
 
-pub use {
-    crate::koto::{Koto, KotoError, KotoSettings},
-    koto_bytecode as bytecode, koto_parser as parser, koto_runtime as runtime,
-};
+pub use crate::koto::{Koto, KotoError, KotoSettings};
+pub use koto_bytecode as bytecode;
+pub use koto_parser as parser;
+pub use koto_runtime as runtime;

core/koto/src/prelude.rs

@@ -1,7 +1,5 @@
 //! A collection of useful items to make it easier to work with `koto`
 
-pub use {
-    crate::{Koto, KotoError, KotoSettings},
-    koto_bytecode::{Chunk, Loader, LoaderError},
-    koto_runtime::prelude::*,
-};
+pub use crate::{Koto, KotoError, KotoSettings};
+pub use koto_bytecode::{Chunk, Loader, LoaderError};
+pub use koto_runtime::prelude::*;

core/koto/tests/docs_examples.rs

@@ -1,10 +1,8 @@
-use {
-    koto::prelude::*,
-    std::{
-        ops::Deref,
-        path::{Path, PathBuf},
-        rc::Rc,
-    },
+use koto::prelude::*;
+use std::{
+    ops::Deref,
+    path::{Path, PathBuf},
+    rc::Rc,
 };
 
 struct ExampleTestRunner {

core/koto/tests/koto_tests.rs

@@ -1,11 +1,9 @@
-use {
-    koto::prelude::*,
-    std::{
-        cell::RefCell,
-        fs::read_to_string,
-        path::{Path, PathBuf},
-        rc::Rc,
-    },
+use koto::prelude::*;
+use std::{
+    cell::RefCell,
+    fs::read_to_string,
+    path::{Path, PathBuf},
+    rc::Rc,
 };
 
 fn run_script(script: &str, script_path: Option<PathBuf>, expected_module_paths: &[PathBuf]) {

core/koto/tests/repl_mode_tests.rs

@@ -5,7 +5,8 @@
 //! The exports map gets populated with any top-level assigned IDs, and is then made available to
 //! each subsequent chunk.
 
-use {koto::prelude::*, std::rc::Rc};
+use koto::prelude::*;
+use std::rc::Rc;
 
 fn run_repl_mode_test(inputs_and_expected_outputs: &[(&str, &str)]) {
     let output = PtrMut::from(String::new());

core/lexer/src/lexer.rs

@@ -1,9 +1,7 @@
-use {
-    crate::{Position, Span},
-    std::{iter::Peekable, str::Chars},
-    unicode_width::UnicodeWidthChar,
-    unicode_xid::UnicodeXID,
-};
+use crate::{Position, Span};
+use std::{iter::Peekable, str::Chars};
+use unicode_width::UnicodeWidthChar;
+use unicode_xid::UnicodeXID;
 
 /// The tokens that can emerge from the lexer
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]

core/lexer/src/lib.rs

@@ -5,7 +5,7 @@
 mod lexer;
 mod span;
 
-pub use {
+pub use crate::{
     lexer::{is_id_continue, is_id_start, KotoLexer as Lexer, Token},
     span::{Position, Span},
 };

core/memory/src/lib.rs

@@ -14,4 +14,4 @@
 
 mod rc;
 
-pub use rc::*;
+pub use crate::rc::*;

core/memory/src/rc/mod.rs

@@ -3,4 +3,5 @@
 mod ptr;
 mod ptr_mut;
 
-pub use {ptr::*, ptr_mut::*};
+pub use ptr::*;
+pub use ptr_mut::*;

core/parser/src/ast.rs

@@ -1,7 +1,5 @@
-use {
-    crate::{error::*, ConstantPool, Node},
-    koto_lexer::Span,
-};
+use crate::{error::*, ConstantPool, Node};
+use koto_lexer::Span;
 
 /// The index type used by nodes in the [Ast]
 pub type AstIndex = u32;

core/parser/src/constant_pool.rs

@@ -1,12 +1,10 @@
-use {
-    crate::{ConstantIndex, ConstantIndexTryFromOutOfRange},
-    koto_memory::Ptr,
-    std::{
-        collections::{hash_map::DefaultHasher, HashMap},
-        fmt,
-        hash::{Hash, Hasher},
-        ops::Range,
-    },
+use crate::{ConstantIndex, ConstantIndexTryFromOutOfRange};
+use koto_memory::Ptr;
+use std::{
+    collections::{hash_map::DefaultHasher, HashMap},
+    fmt,
+    hash::{Hash, Hasher},
+    ops::Range,
 };
 
 // An entry in the list of constants contained in a [ConstantPool]

core/parser/src/error.rs

@@ -1,10 +1,8 @@
-use {
-    koto_lexer::{Position, Span},
-    std::{
-        error,
-        fmt::{self, Write},
-        path::PathBuf,
-    },
+use koto_lexer::{Position, Span};
+use std::{
+    error,
+    fmt::{self, Write},
+    path::PathBuf,
 };
 
 /// An error that represents a problem with the Parser's internal logic, rather than a user error

core/parser/src/lib.rs

@@ -9,12 +9,12 @@ mod error;
 mod node;
 mod parser;
 
-pub use {
+pub use crate::{
     ast::*,
     constant_index::{ConstantIndex, ConstantIndexTryFromOutOfRange},
     constant_pool::{Constant, ConstantPool},
     error::{format_error_with_excerpt, ParserError},
-    koto_lexer::{Position, Span},
     node::*,
     parser::Parser,
 };
+pub use koto_lexer::{Position, Span};

core/parser/src/node.rs

@@ -1,7 +1,5 @@
-use {
-    crate::{ast::AstIndex, ConstantIndex},
-    std::fmt,
-};
+use crate::{ast::AstIndex, ConstantIndex};
+use std::fmt;
 
 /// A parsed node that can be included in the [AST](crate::Ast).
 ///

core/parser/src/parser.rs

@@ -1,17 +1,14 @@
 #![cfg_attr(feature = "panic_on_parser_error", allow(unreachable_code))]
 
-use {
-    crate::{
-        constant_pool::ConstantPoolBuilder,
-        error::{
-            ErrorType as ParserErrorType, ExpectedIndentation, InternalError, ParserError,
-            SyntaxError,
-        },
-        *,
+use crate::{
+    constant_pool::ConstantPoolBuilder,
+    error::{
+        ErrorType as ParserErrorType, ExpectedIndentation, InternalError, ParserError, SyntaxError,
     },
-    koto_lexer::{Lexer, Span, Token},
-    std::{collections::HashSet, str::FromStr},
+    *,
 };
+use koto_lexer::{Lexer, Span, Token};
+use std::{collections::HashSet, str::FromStr};
 
 // Contains info about the current frame, representing either the module's top level or a function
 #[derive(Debug, Default)]
@@ -2793,7 +2790,8 @@ impl<'source> Parser<'source> {
         &mut self,
         context: &ExpressionContext,
     ) -> Result<Option<(AstString, Span, ExpressionContext)>, ParserError> {
-        use {SyntaxError::*, Token::*};
+        use SyntaxError::*;
+        use Token::*;
 
         match self.peek_token_with_context(context) {
             Some(PeekInfo {