@tishlang/tish 1.6.0 → 1.7.0

package/crates/tish_lexer/src/lib.rs

@@ -5,7 +5,7 @@
 
 mod token;
 
-pub use token::{Token, TokenKind, Span};
+pub use token::{Span, Token, TokenKind};
 
 use std::collections::VecDeque;
 use std::iter::Peekable;
@@ -74,14 +74,21 @@ impl<'a> Lexer<'a> {
         loop {
             match self.peek() {
                 None | Some('{') | Some('<') => break,
-                Some(c) => { self.advance(); s.push(c); }
+                Some(c) => {
+                    self.advance();
+                    s.push(c);
+                }
             }
         }
         if s.is_empty() {
             Ok(None)
         } else {
             let end = self.span_start();
-            Ok(Some(Token { kind: TokenKind::JsxText, span: Span { start, end }, literal: Some(s.into()) }))
+            Ok(Some(Token {
+                kind: TokenKind::JsxText,
+                span: Span { start, end },
+                literal: Some(s.into()),
+            }))
         }
     }
 
@@ -139,7 +146,9 @@ impl<'a> Lexer<'a> {
 
     fn skip_line_comment(&mut self) {
         while let Some(c) = self.advance() {
-            if c == '\n' { break; }
+            if c == '\n' {
+                break;
+            }
         }
     }
 
@@ -147,8 +156,14 @@ impl<'a> Lexer<'a> {
         let mut depth = 1;
         while depth > 0 {
             match self.advance() {
-                Some('*') if self.peek() == Some('/') => { self.advance(); depth -= 1; }
-                Some('/') if self.peek() == Some('*') => { self.advance(); depth += 1; }
+                Some('*') if self.peek() == Some('/') => {
+                    self.advance();
+                    depth -= 1;
+                }
+                Some('/') if self.peek() == Some('*') => {
+                    self.advance();
+                    depth += 1;
+                }
                 None => return Err("Unterminated block comment".to_string()),
                 _ => {}
             }
@@ -186,7 +201,11 @@ impl<'a> Lexer<'a> {
 
     fn read_string(&mut self, quote: char) -> Result<String, String> {
         let mut s = String::with_capacity(32);
-        let extra = if quote == '"' { &['"', '\''][..] } else { &['\'', '"'][..] };
+        let extra = if quote == '"' {
+            &['"', '\''][..]
+        } else {
+            &['\'', '"'][..]
+        };
         loop {
             match self.advance() {
                 None => return Err("Unterminated string".to_string()),
@@ -213,24 +232,44 @@ impl<'a> Lexer<'a> {
     }
 
     /// Read a template literal. If `is_continuation` is true, we're continuing after a `}`.
-    fn read_template(&mut self, start: (usize, usize), is_continuation: bool) -> Result<Option<Token>, String> {
+    fn read_template(
+        &mut self,
+        start: (usize, usize),
+        is_continuation: bool,
+    ) -> Result<Option<Token>, String> {
         let mut s = String::with_capacity(if is_continuation { 32 } else { 64 });
         let extra = &['`', '$', '{'][..];
-        
+
         loop {
             match self.advance() {
                 None => return Err("Unterminated template literal".to_string()),
                 Some('`') => {
                     let end = self.span_start();
-                    let kind = if is_continuation { TokenKind::TemplateTail } else { TokenKind::TemplateNoSub };
-                    return Ok(Some(Token { kind, span: Span { start, end }, literal: Some(s.into()) }));
+                    let kind = if is_continuation {
+                        TokenKind::TemplateTail
+                    } else {
+                        TokenKind::TemplateNoSub
+                    };
+                    return Ok(Some(Token {
+                        kind,
+                        span: Span { start, end },
+                        literal: Some(s.into()),
+                    }));
                 }
                 Some('$') if self.peek() == Some('{') => {
                     self.advance();
                     self.template_brace_stack.push(1);
                     let end = self.span_start();
-                    let kind = if is_continuation { TokenKind::TemplateMiddle } else { TokenKind::TemplateHead };
-                    return Ok(Some(Token { kind, span: Span { start, end }, literal: Some(s.into()) }));
+                    let kind = if is_continuation {
+                        TokenKind::TemplateMiddle
+                    } else {
+                        TokenKind::TemplateHead
+                    };
+                    return Ok(Some(Token {
+                        kind,
+                        span: Span { start, end },
+                        literal: Some(s.into()),
+                    }));
                 }
                 Some('\\') => s.push(self.handle_escape(extra)?),
                 Some(c) => s.push(c),
@@ -308,7 +347,10 @@ impl<'a> Lexer<'a> {
                     self.indent_stack.pop();
                     return Ok(Some(Token {
                         kind: TokenKind::Dedent,
-                        span: Span { start: (self.line, self.col), end: (self.line, self.col) },
+                        span: Span {
+                            start: (self.line, self.col),
+                            end: (self.line, self.col),
+                        },
                         literal: None,
                     }));
                 }
@@ -362,31 +404,66 @@ impl<'a> Lexer<'a> {
             ';' => TokenKind::Semicolon,
             ',' => TokenKind::Comma,
             '.' => {
-                if self.peek() == Some('?') { self.advance(); TokenKind::OptionalChain }
-                else if self.peek() == Some('.') {
+                if self.peek() == Some('?') {
                     self.advance();
-                    if self.peek() == Some('.') { self.advance(); TokenKind::Spread }
-                    else { return Err("Unexpected .. (use ... for rest params)".to_string()); }
-                } else { TokenKind::Dot }
+                    TokenKind::OptionalChain
+                } else if self.peek() == Some('.') {
+                    self.advance();
+                    if self.peek() == Some('.') {
+                        self.advance();
+                        TokenKind::Spread
+                    } else {
+                        return Err("Unexpected .. (use ... for rest params)".to_string());
+                    }
+                } else {
+                    TokenKind::Dot
+                }
             }
             '=' => {
                 if self.peek() == Some('=') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::StrictEq } else { TokenKind::Eq }
-                } else if self.peek() == Some('>') { self.advance(); TokenKind::Arrow }
-                else { TokenKind::Assign }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::StrictEq
+                    } else {
+                        TokenKind::Eq
+                    }
+                } else if self.peek() == Some('>') {
+                    self.advance();
+                    TokenKind::Arrow
+                } else {
+                    TokenKind::Assign
+                }
             }
             '!' => {
                 if self.peek() == Some('=') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::StrictNe } else { TokenKind::Ne }
-                } else { TokenKind::Not }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::StrictNe
+                    } else {
+                        TokenKind::Ne
+                    }
+                } else {
+                    TokenKind::Not
+                }
             }
             '<' => {
-                if self.peek() == Some('=') { self.advance(); TokenKind::Le }
-                else if self.peek() == Some('<') { self.advance(); TokenKind::Shl }
-                else if self.peek() == Some('/') { self.jsx_in_closing_tag = true; TokenKind::Lt }
-                else if self.peek() == Some('>') || self.peek().map(|c| c.is_ascii_alphabetic() || c == '_').unwrap_or(false) {
+                if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::Le
+                } else if self.peek() == Some('<') {
+                    self.advance();
+                    TokenKind::Shl
+                } else if self.peek() == Some('/') {
+                    self.jsx_in_closing_tag = true;
+                    TokenKind::Lt
+                } else if self.peek() == Some('>')
+                    || self
+                        .peek()
+                        .map(|c| c.is_ascii_alphabetic() || c == '_')
+                        .unwrap_or(false)
+                {
                     self.jsx_depth += 1;
                     self.jsx_stack.push(JsxEl {
                         in_opener: true,
@@ -394,12 +471,18 @@ impl<'a> Lexer<'a> {
                     });
                     self.jsx_in_opening_tag = true;
                     TokenKind::Lt
-                } else { TokenKind::Lt }
+                } else {
+                    TokenKind::Lt
+                }
             }
             '>' => {
-                if self.peek() == Some('=') { self.advance(); TokenKind::Ge }
-                else if self.peek() == Some('>') { self.advance(); TokenKind::Shr }
-                else {
+                if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::Ge
+                } else if self.peek() == Some('>') {
+                    self.advance();
+                    TokenKind::Shr
+                } else {
                     if self.jsx_in_closing_tag {
                         self.jsx_depth = (self.jsx_depth - 1).max(0);
                         self.jsx_stack.pop();
@@ -425,66 +508,126 @@ impl<'a> Lexer<'a> {
             '^' => TokenKind::BitXor,
             '~' => TokenKind::BitNot,
             '+' => {
-                if self.peek() == Some('+') { self.advance(); TokenKind::PlusPlus }
-                else if self.peek() == Some('=') { self.advance(); TokenKind::PlusAssign }
-                else { TokenKind::Plus }
+                if self.peek() == Some('+') {
+                    self.advance();
+                    TokenKind::PlusPlus
+                } else if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::PlusAssign
+                } else {
+                    TokenKind::Plus
+                }
             }
             '-' => {
-                if self.peek() == Some('-') { self.advance(); TokenKind::MinusMinus }
-                else if self.peek() == Some('=') { self.advance(); TokenKind::MinusAssign }
-                else { TokenKind::Minus }
+                if self.peek() == Some('-') {
+                    self.advance();
+                    TokenKind::MinusMinus
+                } else if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::MinusAssign
+                } else {
+                    TokenKind::Minus
+                }
             }
             '*' => {
-                if self.peek() == Some('*') { self.advance(); TokenKind::StarStar }
-                else if self.peek() == Some('=') { self.advance(); TokenKind::StarAssign }
-                else { TokenKind::Star }
+                if self.peek() == Some('*') {
+                    self.advance();
+                    TokenKind::StarStar
+                } else if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::StarAssign
+                } else {
+                    TokenKind::Star
+                }
             }
             '/' => {
-                if self.peek() == Some('/') { self.advance(); self.skip_line_comment(); return self.next_token(); }
-                else if self.peek() == Some('*') { self.advance(); self.skip_block_comment()?; return self.next_token(); }
-                else if self.peek() == Some('=') { self.advance(); TokenKind::SlashAssign }
-                else {
-                    if self.jsx_in_opening_tag { self.jsx_saw_slash_before_gt = true; }
+                if self.peek() == Some('/') {
+                    self.advance();
+                    self.skip_line_comment();
+                    return self.next_token();
+                } else if self.peek() == Some('*') {
+                    self.advance();
+                    self.skip_block_comment()?;
+                    return self.next_token();
+                } else if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::SlashAssign
+                } else {
+                    if self.jsx_in_opening_tag {
+                        self.jsx_saw_slash_before_gt = true;
+                    }
                     TokenKind::Slash
                 }
             }
             '%' => {
-                if self.peek() == Some('=') { self.advance(); TokenKind::PercentAssign }
-                else { TokenKind::Percent }
+                if self.peek() == Some('=') {
+                    self.advance();
+                    TokenKind::PercentAssign
+                } else {
+                    TokenKind::Percent
+                }
             }
             '&' => {
                 if self.peek() == Some('&') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::AndAndAssign }
-                    else { TokenKind::And }
-                } else { TokenKind::BitAnd }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::AndAndAssign
+                    } else {
+                        TokenKind::And
+                    }
+                } else {
+                    TokenKind::BitAnd
+                }
             }
             '|' => {
                 if self.peek() == Some('|') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::OrOrAssign }
-                    else { TokenKind::Or }
-                } else { TokenKind::BitOr }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::OrOrAssign
+                    } else {
+                        TokenKind::Or
+                    }
+                } else {
+                    TokenKind::BitOr
+                }
             }
             '?' => {
                 if self.peek() == Some('?') {
                     self.advance();
-                    if self.peek() == Some('=') { self.advance(); TokenKind::NullishAssign }
-                    else { TokenKind::NullishCoalesce }
-                } else if self.peek() == Some('.') { self.advance(); TokenKind::OptionalChain }
-                else { TokenKind::Question }
+                    if self.peek() == Some('=') {
+                        self.advance();
+                        TokenKind::NullishAssign
+                    } else {
+                        TokenKind::NullishCoalesce
+                    }
+                } else if self.peek() == Some('.') {
+                    self.advance();
+                    TokenKind::OptionalChain
+                } else {
+                    TokenKind::Question
+                }
             }
             ':' => TokenKind::Colon,
             '"' | '\'' => {
                 let s = self.read_string(c)?;
                 let end = self.span_start();
-                return Ok(Some(Token { kind: TokenKind::String, span: Span { start, end }, literal: Some(s.into()) }));
+                return Ok(Some(Token {
+                    kind: TokenKind::String,
+                    span: Span { start, end },
+                    literal: Some(s.into()),
+                }));
             }
             '`' => return self.read_template(start, false),
             '0'..='9' => {
                 let num = self.read_number(c);
                 let end = self.span_start();
-                return Ok(Some(Token { kind: TokenKind::Number, span: Span { start, end }, literal: Some(num.into()) }));
+                return Ok(Some(Token {
+                    kind: TokenKind::Number,
+                    span: Span { start, end },
+                    literal: Some(num.into()),
+                }));
             }
             'a'..='z' | 'A'..='Z' | '_' => {
                 let ident = self.read_ident_or_keyword(c);
@@ -493,15 +636,26 @@ impl<'a> Lexer<'a> {
                 return Ok(Some(Token {
                     kind,
                     span: Span { start, end },
-                    literal: if matches!(kind, TokenKind::Ident) { Some(ident.into()) } else { None },
+                    literal: if matches!(kind, TokenKind::Ident) {
+                        Some(ident.into())
+                    } else {
+                        None
+                    },
                 }));
             }
-            '\n' => { self.at_line_start = true; return self.next_token(); }
+            '\n' => {
+                self.at_line_start = true;
+                return self.next_token();
+            }
             _ => return Err(format!("Unexpected character: {:?}", c)),
         };
 
         let end = self.span_start();
-        Ok(Some(Token { kind, span: Span { start, end }, literal: None }))
+        Ok(Some(Token {
+            kind,
+            span: Span { start, end },
+            literal: None,
+        }))
     }
 }
 

package/crates/tish_lexer/src/token.rs

@@ -110,14 +110,14 @@ pub enum TokenKind {
     NullishCoalesce,
     Question,
     Arrow,
-    
+
     // Template literal tokens
-    TemplateNoSub,   // `text` (no interpolation)
-    TemplateHead,    // `text${  (start with interpolation)
-    TemplateMiddle,  // }text${  (middle part)
-    TemplateTail,    // }text`   (end part)
+    TemplateNoSub,  // `text` (no interpolation)
+    TemplateHead,   // `text${  (start with interpolation)
+    TemplateMiddle, // }text${  (middle part)
+    TemplateTail,   // }text`   (end part)
 
-    JsxText,  // Raw text in JSX children (emojis, etc.); only {}<> are special
+    JsxText, // Raw text in JSX children (emojis, etc.); only {}<> are special
 }
 
 impl TokenKind {

package/crates/tish_llvm/src/lib.rs

@@ -17,10 +17,15 @@ pub fn compile_to_native(
     project_root: Option<&Path>,
     output_path: &Path,
 ) -> Result<(), LlvmError> {
-    let modules = resolve_project(entry_path, project_root)
-        .map_err(|e| LlvmError { message: e.to_string() })?;
-    detect_cycles(&modules).map_err(|e| LlvmError { message: e.to_string() })?;
-    let program = merge_modules(modules).map_err(|e| LlvmError { message: e.to_string() })?;
+    let modules = resolve_project(entry_path, project_root).map_err(|e| LlvmError {
+        message: e.to_string(),
+    })?;
+    detect_cycles(&modules).map_err(|e| LlvmError {
+        message: e.to_string(),
+    })?;
+    let program = merge_modules(modules).map_err(|e| LlvmError {
+        message: e.to_string(),
+    })?;
     let chunk = tishlang_bytecode::compile(&program).map_err(|e| LlvmError {
         message: e.to_string(),
     })?;
@@ -71,7 +76,10 @@ const uint64_t tish_chunk_len = sizeof(tish_chunk_data);
         .arg(&chunk_c_path)
         .status()
         .map_err(|e| LlvmError {
-            message: format!("Failed to run clang: {}. Install clang (LLVM) or set CLANG env var.", e),
+            message: format!(
+                "Failed to run clang: {}. Install clang (LLVM) or set CLANG env var.",
+                e
+            ),
         })?;
 
     if !status.success() {
@@ -84,9 +92,8 @@ const uint64_t tish_chunk_len = sizeof(tish_chunk_data);
     let object_path_canonical = object_path.canonicalize().map_err(|e| LlvmError {
         message: format!("Cannot canonicalize object path: {}", e),
     })?;
-    tishlang_cranelift::link_to_binary(&object_path_canonical, output_path, features).map_err(|e| LlvmError {
-        message: e.message,
-    })?;
+    tishlang_cranelift::link_to_binary(&object_path_canonical, output_path, features)
+        .map_err(|e| LlvmError { message: e.message })?;
 
     Ok(())
 }

package/crates/tish_lsp/src/main.rs

@@ -7,12 +7,12 @@ use std::sync::{Arc, RwLock};
 use regex::Regex;
 use tower_lsp::jsonrpc::Result;
 use tower_lsp::lsp_types::{
-    CompletionItem, CompletionItemKind, NumberOrString,
-    CompletionParams, CompletionResponse, CompletionTriggerKind, Diagnostic, DiagnosticSeverity,
-    DidChangeTextDocumentParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams,
-    DocumentFormattingParams, DocumentSymbolParams, DocumentSymbolResponse, GotoDefinitionParams,
-    GotoDefinitionResponse, InitializeParams, InitializeResult, Location, MessageType, OneOf,
-    Position, Range, ServerCapabilities, ServerInfo, SymbolInformation, SymbolKind,
+    CompletionItem, CompletionItemKind, CompletionParams, CompletionResponse,
+    CompletionTriggerKind, Diagnostic, DiagnosticSeverity, DidChangeTextDocumentParams,
+    DidCloseTextDocumentParams, DidOpenTextDocumentParams, DocumentFormattingParams,
+    DocumentSymbolParams, DocumentSymbolResponse, GotoDefinitionParams, GotoDefinitionResponse,
+    InitializeParams, InitializeResult, Location, MessageType, NumberOrString, OneOf, Position,
+    Range, ServerCapabilities, ServerInfo, SymbolInformation, SymbolKind,
     TextDocumentPositionParams, TextDocumentSyncCapability, TextDocumentSyncKind, Url,
     WorkspaceSymbolParams,
 };
@@ -171,11 +171,7 @@ impl LanguageServer for Backend {
     }
 
     async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
-        let uri = params
-            .text_document_position
-            .text_document
-            .uri
-            .clone();
+        let uri = params.text_document_position.text_document.uri.clone();
         let _pos = params.text_document_position.position;
         let text = {
             let g = self.docs.read().unwrap();
@@ -223,10 +219,8 @@ impl LanguageServer for Backend {
         }
 
         if let Some(ctx) = params.context {
-            if matches!(
-                ctx.trigger_kind,
-                CompletionTriggerKind::TRIGGER_CHARACTER
-            ) && ctx.trigger_character.as_deref() == Some(".")
+            if matches!(ctx.trigger_kind, CompletionTriggerKind::TRIGGER_CHARACTER)
+                && ctx.trigger_character.as_deref() == Some(".")
             {
                 // After dot: could add member completion later
             }
@@ -294,16 +288,15 @@ impl LanguageServer for Backend {
         if let Some(ref base) = path {
             for s in &program.statements {
                 if let tishlang_ast::Statement::Import {
-                    specifiers,
-                    from,
-                    ..
+                    specifiers, from, ..
                 } = s
                 {
                     for sp in specifiers {
                         let (imported, local) = match sp {
-                            tishlang_ast::ImportSpecifier::Named { name, alias } => {
-                                (name.as_ref(), alias.as_ref().map(|a| a.as_ref()).unwrap_or(name.as_ref()))
-                            }
+                            tishlang_ast::ImportSpecifier::Named { name, alias } => (
+                                name.as_ref(),
+                                alias.as_ref().map(|a| a.as_ref()).unwrap_or(name.as_ref()),
+                            ),
                             tishlang_ast::ImportSpecifier::Default(n) => (n.as_ref(), n.as_ref()),
                             _ => continue,
                         };
@@ -325,9 +318,7 @@ impl LanguageServer for Backend {
                             if let Ok(u) = Url::from_file_path(&can) {
                                 if let Ok(src) = std::fs::read_to_string(&can) {
                                     if let Ok(prog) = tishlang_parser::parse(&src) {
-                                        if let Some(loc) =
-                                            find_export(&prog, imported, &u, &src)
-                                        {
+                                        if let Some(loc) = find_export(&prog, imported, &u, &src) {
                                             return Ok(Some(GotoDefinitionResponse::Scalar(loc)));
                                         }
                                     }
@@ -342,7 +333,10 @@ impl LanguageServer for Backend {
         Ok(None)
     }
 
-    async fn formatting(&self, params: DocumentFormattingParams) -> Result<Option<Vec<tower_lsp::lsp_types::TextEdit>>> {
+    async fn formatting(
+        &self,
+        params: DocumentFormattingParams,
+    ) -> Result<Option<Vec<tower_lsp::lsp_types::TextEdit>>> {
         let uri = params.text_document.uri;
         let text = {
             let g = self.docs.read().unwrap();
@@ -365,10 +359,7 @@ impl LanguageServer for Backend {
             }
             Err(e) => {
                 self.client
-                    .show_message(
-                        MessageType::ERROR,
-                        format!("tish-fmt (formatter): {}", e),
-                    )
+                    .show_message(MessageType::ERROR, format!("tish-fmt (formatter): {}", e))
                     .await;
                 Ok(None)
             }
@@ -499,14 +490,18 @@ fn find_decl_in_stmt(
     text: &str,
 ) -> Option<Location> {
     match s {
-        tishlang_ast::Statement::FunDecl { name, span, .. } if name.as_ref() == word => Some(Location {
-            uri: uri.clone(),
-            range: span_to_range(span, text),
-        }),
-        tishlang_ast::Statement::VarDecl { name, span, .. } if name.as_ref() == word => Some(Location {
-            uri: uri.clone(),
-            range: span_to_range(span, text),
-        }),
+        tishlang_ast::Statement::FunDecl { name, span, .. } if name.as_ref() == word => {
+            Some(Location {
+                uri: uri.clone(),
+                range: span_to_range(span, text),
+            })
+        }
+        tishlang_ast::Statement::VarDecl { name, span, .. } if name.as_ref() == word => {
+            Some(Location {
+                uri: uri.clone(),
+                range: span_to_range(span, text),
+            })
+        }
         tishlang_ast::Statement::Block { statements, .. } => {
             for x in statements {
                 if let Some(l) = find_decl_in_stmt(x, word, uri, text) {
@@ -521,8 +516,14 @@ fn find_decl_in_stmt(
 
 fn span_to_range(span: &tishlang_ast::Span, _text: &str) -> Range {
     Range {
-        start: pos(span.start.0.saturating_sub(1) as u32, span.start.1.saturating_sub(1) as u32),
-        end: pos(span.end.0.saturating_sub(1) as u32, span.end.1.saturating_sub(1) as u32),
+        start: pos(
+            span.start.0.saturating_sub(1) as u32,
+            span.start.1.saturating_sub(1) as u32,
+        ),
+        end: pos(
+            span.end.0.saturating_sub(1) as u32,
+            span.end.1.saturating_sub(1) as u32,
+        ),
     }
 }
 
@@ -556,10 +557,7 @@ fn doc_symbol_stmt(
 ) {
     match s {
         tishlang_ast::Statement::FunDecl {
-            name,
-            span,
-            body,
-            ..
+            name, span, body, ..
         } => {
             let mut children = Vec::new();
             collect_child_syms(body, text, &mut children);

package/crates/tish_native/src/build.rs

@@ -127,11 +127,7 @@ lto = "thin"
 [dependencies]
 tishlang_runtime = {{ path = {:?}{} }}
 {}{}"#,
-        out_name,
-        runtime_path,
-        features_str,
-        more_deps,
-        ui_dep
+        out_name, runtime_path, features_str, more_deps, ui_dep
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)
@@ -182,4 +178,3 @@ mod tests {
         assert_eq!(f.len(), 5);
     }
 }
-