refactor: prefer default over new

Author: alexander-jackson

src/app.rs

@@ -107,7 +107,7 @@ fn process_path(path: &OsStr, args: &Args) -> Result<(), Box<dyn Error>> {
     let mut ast = get_abstract_syntax_tree(&code, args.abstract_tree)?;
 
     // Infer as many types as we can in a single pass and return to the start
-    let mut context = Context::new();
+    let mut context = Context::default();
     ast.infer(&mut context);
     context.reset_position();
 

src/ast/context.rs

@@ -15,7 +15,7 @@ use crate::ast::{SymbolTable, VariableType};
 ///
 /// Stores the current function name if we are inside one, the return types of functions, their
 /// argument names and types, and any external `#include`s that are needed.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Context {
     /// Stores the currently defined variables and deals with scoping rules
     symbol_table: SymbolTable,
@@ -34,21 +34,6 @@ pub struct Context {
 }
 
 impl Context {
-    /// Creates a new Context.
-    ///
-    /// This assumes that nothing has been learnt about the program yet.
-    pub fn new() -> Context {
-        Context {
-            symbol_table: SymbolTable::new(),
-            current_function: None,
-            function_return_types: HashMap::new(),
-            function_argument_types: HashMap::new(),
-            function_argument_names: HashMap::new(),
-            includes: HashSet::new(),
-            header_includes: HashSet::new(),
-        }
-    }
-
     /// Push a new scope into the `SymbolTable`.
     pub fn push_scope(&mut self) {
         self.symbol_table.push_scope();
@@ -313,7 +298,7 @@ impl Context {
     /// ```
     /// use ptc::ast::Context;
     ///
-    /// let mut context = Context::new();
+    /// let mut context = Context::default();
     /// assert!(context.in_global_scope());
     ///
     /// context.push_scope();
@@ -326,9 +311,3 @@ impl Context {
         self.symbol_table.in_global_scope()
     }
 }
-
-impl Default for Context {
-    fn default() -> Context {
-        Context::new()
-    }
-}

src/ast/mod.rs

@@ -81,7 +81,7 @@ impl Infer for Suite {
 /// use ptc::ast::{Context, DataType, Literal, VariableType};
 ///
 /// let node = Literal::Float { value: 0.5 };
-/// let mut context = Context::new();
+/// let mut context = Context::default();
 /// assert_eq!(node.get_type(&mut context), Some(VariableType::Float));
 /// ```
 pub trait DataType {

src/ast/symboltable.rs

@@ -28,7 +28,7 @@ impl VariableInformation {
 }
 
 /// Stores a single scope layer with the variables defined within it.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Scope {
     /// The variables defined in this scope
     variables: HashMap<String, VariableInformation>,
@@ -39,25 +39,13 @@ pub struct Scope {
 }
 
 impl Scope {
-    /// Creates a new Scope.
-    ///
-    /// Initialises a new scope with an empty `HashMap` for Variables, no known subscopes and marks
-    /// it as unexplored thusfar.
-    pub fn new() -> Scope {
-        Scope {
-            variables: HashMap::new(),
-            subscopes: Vec::new(),
-            explored: false,
-        }
-    }
-
     /// Push a new scope into the symbol table, returning the new index that it was inserted into.
     pub fn push_scope(&mut self, indices: &[usize]) -> usize {
         if let Some((head, tail)) = indices.split_first() {
             return self.subscopes[*head].push_scope(tail);
         }
 
-        self.subscopes.push(Scope::new());
+        self.subscopes.push(Scope::default());
         self.subscopes.len() - 1
     }
 
@@ -186,7 +174,7 @@ impl Scope {
 }
 
 /// Defines the `SymbolTable` used in the Context.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct SymbolTable {
     /// The global scope, which all scopes descend from
     scope: Scope,
@@ -195,14 +183,6 @@ pub struct SymbolTable {
 }
 
 impl SymbolTable {
-    /// Creates a new `SymbolTable` with an empty global scope.
-    pub fn new() -> SymbolTable {
-        SymbolTable {
-            scope: Scope::new(),
-            active: Vec::new(),
-        }
-    }
-
     /// Push a new scope into the currently active one. This implies we are going into a new level
     /// of nesting, such as a function definition, if statement or while statement.
     pub fn push_scope(&mut self) {

tests/codegen.rs

@@ -7,7 +7,7 @@ fn get_output(input: &str) -> String {
     let lexer = ptc::lexer::Lexer::new(input.char_indices());
     let mut ast = parser.parse(lexer).unwrap();
 
-    let mut context = Context::new();
+    let mut context = Context::default();
     ast.infer(&mut context);
 
     context.reset_position();