Run rustfmt on schala.rs

schala-lang/language/src/schala.rs

@@ -1,10 +1,11 @@
 use stopwatch::Stopwatch;
 
-use schala_repl::{ProgrammingLanguageInterface,
-ComputationRequest, ComputationResponse,
-LangMetaRequest, LangMetaResponse, GlobalOutputStats};
-use crate::{reduced_ast, tokenizing, parsing, eval, typechecking, symbol_table};
 use crate::error::SchalaError;
+use crate::{eval, parsing, reduced_ast, symbol_table, tokenizing, typechecking};
+use schala_repl::{
+    ComputationRequest, ComputationResponse, GlobalOutputStats, LangMetaRequest, LangMetaResponse,
+    ProgrammingLanguageInterface,
+};
 
 /// All the state necessary to parse and execute a Schala program are stored in this struct.
 pub struct Schala {
@@ -39,7 +40,7 @@ impl Schala {
             symbol_table: symbol_table::SymbolTable::new(),
             state: eval::State::new(),
             type_context: typechecking::TypeContext::new(),
-      active_parser: parsing::Parser::new()
+            active_parser: parsing::Parser::new(),
         }
     }
 
@@ -65,21 +66,26 @@ impl Schala {
         // TODO tokenize should return its own error type
         let tokens = tokenizing::tokenize(source);
         if let Some(err) = SchalaError::from_tokens(&tokens) {
-      return Err(err)
+            return Err(err);
         }
 
         //2nd stage - parsing
         self.active_parser.add_new_tokens(tokens);
-    let ast = self.active_parser.parse()
+        let ast = self
+            .active_parser
+            .parse()
             .map_err(|err| SchalaError::from_parse_error(err, &self.source_reference))?;
 
         //Perform all symbol table work
-    self.symbol_table.process_ast(&ast)
+        self.symbol_table
+            .process_ast(&ast)
             .map_err(SchalaError::from_symbol_table)?;
 
         // Typechecking
         // TODO typechecking not working
-    let _overall_type = self.type_context.typecheck(&ast)
+        let _overall_type = self
+            .type_context
+            .typecheck(&ast)
             .map_err(SchalaError::from_type_error);
 
         // Reduce AST - TODO this doesn't produce an error yet, but probably should
@@ -87,24 +93,21 @@ impl Schala {
 
         // Tree-walking evaluator. TODO fix this
         let evaluation_outputs = self.state.evaluate(reduced_ast, true);
-    let text_output: Result<Vec<String>, String> = evaluation_outputs
+        let text_output: Result<Vec<String>, String> = evaluation_outputs.into_iter().collect();
-      .into_iter()
-      .collect();
 
-    let text_output: Result<Vec<String>, SchalaError> = text_output
+        let text_output: Result<Vec<String>, SchalaError> =
-      .map_err(|err| SchalaError::from_string(err, Stage::Evaluation));
+            text_output.map_err(|err| SchalaError::from_string(err, Stage::Evaluation));
 
-    let eval_output: String = text_output
+        let eval_output: String =
-      .map(|v| { Iterator::intersperse(v.into_iter(), "\n".to_owned()).collect() })?;
+            text_output.map(|v| Iterator::intersperse(v.into_iter(), "\n".to_owned()).collect())?;
 
         Ok(eval_output)
     }
 }
 
-
 /// Represents lines of source code
 pub(crate) struct SourceReference {
-  lines: Option<Vec<String>>
+    lines: Option<Vec<String>>,
 }
 
 impl SourceReference {
@@ -114,10 +117,14 @@ impl SourceReference {
 
     fn load_new_source(&mut self, source: &str) {
         //TODO this is a lot of heap allocations - maybe there's a way to make it more efficient?
-    self.lines = Some(source.lines().map(|s| s.to_string()).collect()); }
+        self.lines = Some(source.lines().map(|s| s.to_string()).collect());
+    }
 
     pub fn get_line(&self, line: usize) -> String {
-    self.lines.as_ref().and_then(|x| x.get(line).map(|s| s.to_string())).unwrap_or_else(|| "NO LINE FOUND".to_string())
+        self.lines
+            .as_ref()
+            .and_then(|x| x.get(line).map(|s| s.to_string()))
+            .unwrap_or_else(|| "NO LINE FOUND".to_string())
     }
 }
 
@@ -138,14 +145,12 @@ fn stage_names() -> Vec<&'static str> {
         "tokenizing",
         "parsing",
         "symbol-table",
-    "scope-resolution",
         "typechecking",
         "ast-reduction",
-    "ast-walking-evaluation"
+        "ast-walking-evaluation",
     ]
 }
 
-
 impl ProgrammingLanguageInterface for Schala {
     type Config = ();
     fn language_name() -> String {
@@ -156,30 +161,43 @@ impl ProgrammingLanguageInterface for Schala {
         "schala".to_owned()
     }
 
-  fn run_computation(&mut self, request: ComputationRequest<Self::Config>) -> ComputationResponse {
+    fn run_computation(
-    let ComputationRequest { source, debug_requests: _, config: _ } = request;
+        &mut self,
+        request: ComputationRequest<Self::Config>,
+    ) -> ComputationResponse {
+        let ComputationRequest {
+            source,
+            debug_requests: _,
+            config: _,
+        } = request;
         self.source_reference.load_new_source(source);
         let sw = Stopwatch::start_new();
 
-    let main_output = self.run_pipeline(source)
+        let main_output = self
+            .run_pipeline(source)
             .map_err(|schala_err| schala_err.display());
 
         let global_output_stats = GlobalOutputStats {
             total_duration: sw.elapsed(),
-      stage_durations: vec![]
+            stage_durations: vec![],
         };
 
         ComputationResponse {
             main_output,
             global_output_stats,
-      debug_responses: vec![]
+            debug_responses: vec![],
         }
     }
 
     fn request_meta(&mut self, request: LangMetaRequest) -> LangMetaResponse {
         match request {
-      LangMetaRequest::StageNames => LangMetaResponse::StageNames(stage_names().iter().map(|s| s.to_string()).collect()),
+            LangMetaRequest::StageNames => {
-      _ => LangMetaResponse::Custom { kind: "not-implemented".to_string(), value: "".to_string() }
+                LangMetaResponse::StageNames(stage_names().iter().map(|s| s.to_string()).collect())
+            }
+            _ => LangMetaResponse::Custom {
+                kind: "not-implemented".to_string(),
+                value: "".to_string(),
+            },
         }
     }
 }