Merge pull request #359 from koto-lang/inline-strings

Inline strings

Author: irh

CHANGELOG.md

@@ -15,7 +15,7 @@ The Koto project adheres to
 - Type hints with runtime type checks have been added ([#298](https://github.com/koto-lang/koto/issues/298)).
   - Thanks to [@Tarbetu](https://github.com/Tarbetu) for the contributions.
 - `export` can be used with multi-assignment expressions.
-  - e.g. expressions like `export a, b, c = foo()` are now allowed.
+  - E.g. expressions like `export a, b, c = foo()` are now allowed.
 - Maps now support `[]` indexing, returning the Nth entry as a tuple.
 - Objects that implement `KotoObject::call` can now be used in operations that
   expect functions.
@@ -61,6 +61,7 @@ The Koto project adheres to
     `unexpected_args_after_instance`. 
 - `From` impls for `KNumber` now saturate integer values that are out of the
   target type's bounds, instead of wrapping.
+- `KString` will now inline short strings to reduce allocations.
 
 ### Removed
 

crates/derive/src/koto_impl.rs

@@ -1,4 +1,3 @@
-use crate::PREFIX_FUNCTION;
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
 use syn::{
@@ -7,6 +6,8 @@ use syn::{
     Type, TypePath,
 };
 
+const PREFIX_FUNCTION: &str = "__koto_";
+
 struct KotoImplParser {
     runtime_path: Path,
 }

crates/derive/src/koto_type.rs

@@ -1,6 +1,6 @@
-use crate::{attributes::koto_derive_attributes, PREFIX_STATIC};
+use crate::attributes::koto_derive_attributes;
 use proc_macro::TokenStream;
-use quote::{format_ident, quote};
+use quote::quote;
 use syn::{parse_macro_input, DeriveInput};
 
 pub fn derive_koto_type(input: TokenStream) -> TokenStream {
@@ -14,23 +14,37 @@ pub fn derive_koto_type(input: TokenStream) -> TokenStream {
         .type_name
         .unwrap_or_else(|| quote!(#name).to_string());
 
-    let type_string_name = format_ident!("{PREFIX_STATIC}TYPE_STRING_{}", type_name.to_uppercase());
-
-    let result = quote! {
-        #[automatically_derived]
-        impl #impl_generics KotoType for #name #ty_generics #where_clause {
-            fn type_static() -> &'static str {
-                #type_name
-            }
-
-            fn type_string(&self) -> KString {
-                #type_string_name.with(KString::clone)
+    // Short type names don't need to be cached, 22 is the `MAX_INLINE_STRING_LEN` constant
+    let result = if type_name.len() <= 22 {
+        quote! {
+            #[automatically_derived]
+            impl #impl_generics KotoType for #name #ty_generics #where_clause {
+                fn type_static() -> &'static str {
+                    #type_name
+                }
+
+                fn type_string(&self) -> KString {
+                    #type_name.into()
+                }
             }
         }
+    } else {
+        quote! {
+            #[automatically_derived]
+            impl #impl_generics KotoType for #name #ty_generics #where_clause {
+                fn type_static() -> &'static str {
+                    #type_name
+                }
+
+                fn type_string(&self) -> KString {
+                    thread_local! {
+                        static TYPE_NAME: KString = #type_name.into();
+                    }
+
+                    TYPE_NAME.with(KString::clone)
+                }
+            }
 
-        #[automatically_derived]
-        thread_local! {
-            static #type_string_name: KString = #type_name.into();
         }
     };
 

crates/derive/src/lib.rs

@@ -142,6 +142,3 @@ pub fn koto_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
 pub fn koto_method(_attr: TokenStream, item: TokenStream) -> TokenStream {
     item
 }
-
-const PREFIX_STATIC: &str = "__KOTO_";
-const PREFIX_FUNCTION: &str = "__koto_";

crates/parser/src/constant_pool.rs

@@ -52,7 +52,7 @@ enum ConstantEntry {
     F64(f64),
     // An i64 constant
     I64(i64),
-    // The range in bytes in the ConstantPool's string data for a string constant
+    // The range in bytes in the `ConstantPool`'s string data for a string constant
     Str(Range<usize>),
 }
 
@@ -327,7 +327,7 @@ mod tests {
         assert_eq!(ConstantIndex(0), builder.add_string(s1).unwrap());
         assert_eq!(ConstantIndex(1), builder.add_string(s2).unwrap());
 
-        // don't duplicate string_data
+        // Don't duplicate string_data
         assert_eq!(ConstantIndex(0), builder.add_string(s1).unwrap());
         assert_eq!(ConstantIndex(1), builder.add_string(s2).unwrap());
 
@@ -349,7 +349,7 @@ mod tests {
         assert_eq!(ConstantIndex(0), builder.add_i64(n1).unwrap());
         assert_eq!(ConstantIndex(1), builder.add_f64(n2).unwrap());
 
-        // don't duplicate numbers
+        // Don't duplicate numbers
         assert_eq!(ConstantIndex(0), builder.add_i64(n1).unwrap());
         assert_eq!(ConstantIndex(1), builder.add_f64(n2).unwrap());
 

crates/parser/src/error.rs

@@ -203,7 +203,7 @@ pub enum SyntaxError {
     UnterminatedString,
 }
 
-/// See [ParserError]
+/// See [`ParserError`]
 #[derive(Error, Clone, Debug)]
 #[allow(missing_docs)]
 pub enum ErrorKind {

crates/parser/src/node.rs

@@ -2,19 +2,19 @@ use crate::{ast::AstIndex, constant_pool::ConstantIndex, StringFormatOptions, St
 use smallvec::SmallVec;
 use std::fmt;
 
-/// The vec type used in the AST
+/// The Vec type used in the AST
 //
-//  Q. Why 4 elements in the small vec?
+//  Q. Why 4 elements in the small Vec?
 //  A. It's the maximum number of elements that can be used in [Node] without increasing its overall
 //     size.
 pub type AstVec<T> = SmallVec<[T; 4]>;
 
-/// A convenience macro for initializing [AstVec]s
+/// A convenience macro for initializing an [`AstVec`]
 pub use smallvec::smallvec as astvec;
 
 /// A parsed node that can be included in the [AST](crate::Ast).
 ///
-/// Nodes refer to each other via [AstIndex]s, see [AstNode](crate::AstNode).
+/// Nodes refer to each other via [`AstIndex`], see [`AstNode`](crate::AstNode).
 #[derive(Clone, Debug, Default, PartialEq, Eq, derive_name::VariantName)]
 pub enum Node {
     /// The `null` keyword
@@ -24,14 +24,14 @@ pub enum Node {
     /// A single expression wrapped in parentheses
     Nested(AstIndex),
 
-    /// An identifer, and optionally the type hint node
+    /// An identifier, and optionally the type hint node
     Id(ConstantIndex, Option<AstIndex>),
 
     /// A meta identifier, e.g. `@display` or `@test my_test`
     Meta(MetaKeyId, Option<ConstantIndex>),
 
     /// A chained expression, and optionally the node that follows it in the chain
-    Chain((ChainNode, Option<AstIndex>)), // chain node, next node
+    Chain((ChainNode, Option<AstIndex>)), // Chain node, next node
 
     /// The `true` keyword
     BoolTrue,
@@ -53,12 +53,12 @@ pub enum Node {
 
     /// A list literal
     ///
-    /// e.g. `[foo, bar, 42]`
+    /// E.g. `[foo, bar, 42]`
     List(AstVec<AstIndex>),
 
     /// A tuple literal
     ///
-    /// e.g. `(foo, bar, 42)`
+    /// E.g. `(foo, bar, 42)`
     ///
     /// Note that this is also used for implicit tuples, e.g. in `x = 1, 2, 3`
     Tuple(AstVec<AstIndex>),
@@ -78,8 +78,8 @@ pub enum Node {
         end: AstIndex,
         /// Whether or not the end of the range includes the end value itself
         ///
-        /// e.g. `1..10` - a range from 1 up to but not including 10
-        /// e.g. `1..=10` - a range from 1 up to and including 10
+        /// E.g. `1..10` - a range from 1 up to but not including 10
+        /// E.g. `1..=10` - a range from 1 up to and including 10
         inclusive: bool,
     },
 
@@ -128,15 +128,15 @@ pub enum Node {
     /// A block node
     ///
     /// Used for indented blocks that share the context of the frame they're in,
-    /// e.g. if expressions, arms in match or switch experssions, loop bodies
+    /// e.g. if expressions, arms in match or switch expressions, loop bodies.
     Block(AstVec<AstIndex>),
 
     /// A function node
     Function(Function),
 
     /// An import expression
     ///
-    /// e.g. `from foo.bar import baz, 'qux'
+    /// E.g. `from foo.bar import baz, 'qux'`
     Import {
         /// Where the items should be imported from
         ///
@@ -163,7 +163,7 @@ pub enum Node {
 
     /// A multiple-assignment expression
     ///
-    /// e.g. `x, y = foo()`, or `foo, bar, baz = 1, 2, 3`
+    /// E.g. `x, y = foo()`, or `foo, bar, baz = 1, 2, 3`
     MultiAssign {
         /// The targets of the assignment
         targets: AstVec<AstIndex>,
@@ -269,7 +269,7 @@ pub enum Node {
 
     /// A type hint
     ///
-    /// e.g. `let x: Number = 0`
+    /// E.g. `let x: Number = 0`
     ///            ^~~ This is the beginning of the type hint
     Type(ConstantIndex),
 }

crates/parser/src/string_slice.rs

@@ -1,5 +1,5 @@
 use koto_memory::Ptr;
-use std::ops::Range;
+use std::ops::{Deref, Range};
 
 /// String data with bounds
 ///
@@ -11,7 +11,7 @@ pub struct StringSlice {
 }
 
 impl StringSlice {
-    /// Initalizes a string slice with the given string data and bounds
+    /// Initializes a string slice with the given string data and bounds
     ///
     /// If the bounds aren't valid for the given string data then None is returned.
     pub fn new(string: Ptr<str>, bounds: Range<usize>) -> Option<Self> {
@@ -25,11 +25,11 @@ impl StringSlice {
         }
     }
 
-    /// Initalizes a string slice with the given string data and bounds
+    /// Initializes a string slice with the given string data and bounds
     ///
     /// # Safety
     /// Care must be taken to ensure that the bounds are valid within the provided string,
-    /// i.e. string.get(bounds).is_some() must be true.
+    /// i.e. `string.get(bounds).is_some()` must be true.
     pub unsafe fn new_unchecked(string: Ptr<str>, bounds: Range<usize>) -> Self {
         Self {
             data: string,
@@ -98,9 +98,17 @@ impl From<String> for StringSlice {
     }
 }
 
+impl Deref for StringSlice {
+    type Target = str;
+
+    fn deref(&self) -> &str {
+        self.as_str()
+    }
+}
+
 impl AsRef<str> for StringSlice {
     fn as_ref(&self) -> &str {
-        self.as_str()
+        self.deref()
     }
 }
 

crates/runtime/src/io/stdio.rs

@@ -7,7 +7,7 @@ pub struct DefaultStdin {}
 
 impl KotoFile for DefaultStdin {
     fn id(&self) -> KString {
-        STDIN_ID.with(|id| id.clone())
+        "_stdin_".into()
     }
 }
 
@@ -35,7 +35,7 @@ pub struct DefaultStdout {}
 
 impl KotoFile for DefaultStdout {
     fn id(&self) -> KString {
-        STDOUT_ID.with(|id| id.clone())
+        "_stdout_".into()
     }
 }
 
@@ -63,7 +63,7 @@ pub struct DefaultStderr {}
 
 impl KotoFile for DefaultStderr {
     fn id(&self) -> KString {
-        STDERR_ID.with(|id| id.clone())
+        "_stderr_".into()
     }
 }
 
@@ -84,9 +84,3 @@ impl KotoWrite for DefaultStderr {
         io::stdout().flush().map_err(map_io_err)
     }
 }
-
-thread_local! {
-    static STDIN_ID: KString = "_stdin_".into();
-    static STDOUT_ID: KString = "_stdout_".into();
-    static STDERR_ID: KString = "_stderr_".into();
-}