Add basic optimizations

README.md

@@ -46,15 +46,15 @@ Candy blurs the line between those stages, for example, by replacing compile-tim
   ```candy
   foo a =             # If you pass a = 0,
     needs (isInt a)
-    math.logarithm a  # then this fails because logarithm only works on positive numbers.
+    math.logarithm a  # then this panics: The `input` must be a positive number.
 
   efficientTextReverse text =
     needs (isText text)
-    needs (isPalindrome text) "efficientTextReverse only works on palindromes"
+    needs (isPalindrome text) "Only palindromes can be efficiently reversed."
     text
 
   greetBackwards name =                   # If you pass name = "Test",
-    "Hello, {efficientTextReverse name}"  # then this fails because efficientTextReverse only works on palindromes.
+    "Hello, {efficientTextReverse name}"  # then this panics: Only palindromes can be efficiently reversed.
   ```
 
 To get a more in-depth introduction, read the [language document](language.md).
@@ -135,16 +135,13 @@ We already have a language server that provides some tooling.
 
 ## Short-term TODOs
 
-- fix fault attribution
 - new name?
 - add caching while compile-time evaluating code
 - tags
 - pattern matching
-- add CI
 - add tests
 - add a more lightweight tracer that only tracks stack traces
 - text interpolation
-- optimize: eliminate common subtrees
 - optimize: inline functions
 - minimize inputs found through fuzzing
 - fuzz parser
@@ -155,6 +152,8 @@ We already have a language server that provides some tooling.
 - distinguish packages from normal modules
 - complain about comment lines with too much indentation
 - develop guidelines about how to format reasons
+- disallow passing named closures as parameters? or auto-propagate caller's fault to called parameters?
+- replace occurrences of `Id::complicated_responsibility()`
 
 ## How to use Candy
 

compiler/src/compiler/README.md

@@ -8,8 +8,9 @@ These are the compiler stages:
 * RCST ("Raw Concrete Syntax Tree"): A tree that represents the syntax of the code, including every single character and whitespace.
 * CST ("Concrete Syntax Tree"): Similar to RCST, but tree nodes also have IDs and know what ranges in the source file they correspond to.
 * AST ("Abstract Syntax Tree"): A tree where unnecessary cruft is removed and some invariants are validated.
-* HIR ("High-level Intermediate Representation"): The canonical representation of source code in single-static-assignment form (SSA).
-* LIR ("Low-level Intermediate Representation"): An instruction code for a stack-based virtual machine.
+* HIR ("High-Level Intermediate Representation"): The canonical representation of source code in single-static-assignment form (SSA).
+* MIR ("Mid-Level Intermediate Representation"): A representation with explicit tracking of responsibilities and desugaring. Tailored for applying optimizations.
+* LIR ("Low-Level Intermediate Representation"): An instruction code for a stack-based virtual machine.
 
 Note that if an error occurs in a compilation stage, we don't immediately abort but rather just try to contain the error in a subtree of the code and emit an error node.
 This means that even if you have a syntax error (missing parentheses, etc.), the tooling in other parts of the source still works – including auto-completion, edit-time evaluation, formatting, etc.

compiler/src/compiler/ast_to_hir.rs

@@ -30,7 +30,7 @@ pub trait AstToHir: CstDb + CstToAst {
 }
 
 fn hir_to_ast_id(db: &dyn AstToHir, id: hir::Id) -> Option<ast::Id> {
-    let (_, hir_to_ast_id_mapping) = db.hir(id.module.clone()).unwrap();
+    let (_, hir_to_ast_id_mapping) = db.hir(id.module.clone())?;
     hir_to_ast_id_mapping.get(&id).cloned()
 }
 fn hir_to_cst_id(db: &dyn AstToHir, id: hir::Id) -> Option<cst::Id> {
@@ -337,29 +337,29 @@ impl<'a> Context<'a> {
             })) if name == "needs" => {
                 let expression = match &self.lower_call_arguments(&call.arguments[..])[..] {
                     [condition, reason] => Expression::Needs {
-                        condition: Box::new(condition.clone()),
-                        reason: Box::new(reason.clone()),
+                        condition: condition.clone(),
+                        reason: reason.clone(),
                     },
                     [condition] => Expression::Needs {
-                        condition: Box::new(condition.clone()),
-                        reason: Box::new(self.push(
+                        condition: condition.clone(),
+                        reason: self.push(
                             None,
                             Expression::Text(
                                 match self.db.ast_id_to_span(call.arguments[0].id.clone()) {
                                     Some(span) => format!(
-                                            "`{}` was not satisfied",
-                                            &self
-                                                .db
-                                                .get_module_content_as_string(
-                                                    call.arguments[0].id.module.clone()
-                                                )
-                                                .unwrap()[span],
-                                        ),
+                                        "`{}` was not satisfied",
+                                        &self
+                                            .db
+                                            .get_module_content_as_string(
+                                                call.arguments[0].id.module.clone()
+                                            )
+                                            .unwrap()[span],
+                                    ),
                                     None => "the needs of a function were not met".to_string(),
                                 },
                             ),
                             None,
-                        )),
+                        ),
                     },
                     _ => {
                         return self.push_error(
@@ -459,7 +459,7 @@ impl<'a> Context<'a> {
 
 impl<'a> Context<'a> {
     fn generate_sparkles(&mut self) {
-        let mut sparkles_map = im::HashMap::new();
+        let mut sparkles_map = HashMap::new();
 
         for builtin_function in builtin_functions::VALUES.iter() {
             let symbol = self.push(
@@ -505,7 +505,7 @@ impl<'a> Context<'a> {
             Expression::Lambda(Lambda {
                 parameters: vec![relative_path],
                 body: inner_body,
-                fuzzable: false,
+                fuzzable: true,
             }),
             Some("use".to_string()),
         );
@@ -517,7 +517,7 @@ impl<'a> Context<'a> {
         //   HirId(~:test.candy:100): HirId(~:test.candy:101),
         // ]
 
-        let mut exports = im::HashMap::new();
+        let mut exports = HashMap::new();
         for (name, id) in self.public_identifiers.clone() {
             exports.insert(
                 self.push(

compiler/src/compiler/cst_to_ast.rs

@@ -58,7 +58,7 @@ fn ast(db: &dyn CstToAst, module: Module) -> Option<AstResult> {
             let cst = cst.unwrap_whitespace_and_comment();
             context.lower_csts(&cst)
         }
-        Err(InvalidModuleError::DoesNotExist) => return None,
+        Err(InvalidModuleError::DoesNotExist | InvalidModuleError::IsToolingModule) => return None,
         Err(InvalidModuleError::InvalidUtf8) => {
             vec![Ast {
                 id: context.create_next_id_without_mapping(),

compiler/src/compiler/error.rs

@@ -1,6 +1,6 @@
 use super::{ast::AstError, hir::HirError, rcst::RcstError};
 use crate::module::Module;
-use std::ops::Range;
+use std::{fmt::Display, ops::Range};
 
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub struct CompilerError {
@@ -16,3 +16,84 @@ pub enum CompilerErrorPayload {
     Ast(AstError),
     Hir(HirError),
 }
+
+impl Display for CompilerErrorPayload {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let message = match self {
+            CompilerErrorPayload::InvalidUtf8 => "The module contains invalid UTF-8.".to_string(),
+            CompilerErrorPayload::Rcst(error) => match error {
+                RcstError::CurlyBraceNotClosed => "The curly brace is not closed.",
+                RcstError::IdentifierContainsNonAlphanumericAscii => {
+                    "This identifier contains non-alphanumeric ASCII characters."
+                }
+                RcstError::IntContainsNonDigits => {
+                    "This integer contains characters that are not digits."
+                }
+                RcstError::ListItemMissesValue => "This list item is missing a value.",
+                RcstError::ListNotClosed => "The list is not closed.",
+                RcstError::OpeningParenthesisWithoutExpression => {
+                    "Here's an opening parenthesis without an expression after it."
+                }
+                RcstError::ParenthesisNotClosed => "This parenthesis isn't closed.",
+                RcstError::PipeMissesCall => "There should be a call after this pipe.",
+                RcstError::StructFieldMissesColon => "This struct field misses a colon.",
+                RcstError::StructFieldMissesKey => "This struct field misses a key.",
+                RcstError::StructFieldMissesValue => "This struct field misses a value.",
+                RcstError::StructNotClosed => "This struct is not closed.",
+                RcstError::SymbolContainsNonAlphanumericAscii => {
+                    "This symbol contains non-alphanumeric ASCII characters."
+                }
+                RcstError::TextNotClosed => "This text isn't closed.",
+                RcstError::TextNotSufficientlyIndented => "This text isn't sufficiently indented.",
+                RcstError::TooMuchWhitespace => "There is too much whitespace here.",
+                RcstError::UnexpectedCharacters => "This is an unexpected character.",
+                RcstError::UnparsedRest => "The parser couldn't parse this rest.",
+                RcstError::WeirdWhitespace => "This is weird whitespace.",
+                RcstError::WeirdWhitespaceInIndentation => {
+                    "This is weird whitespace. Make sure to use indent using two spaces."
+                }
+            }
+            .to_string(),
+            CompilerErrorPayload::Ast(error) => match error {
+                AstError::ExpectedParameter => "A parameter should come here.",
+                AstError::LambdaWithoutClosingCurlyBrace => {
+                    "This lambda doesn't have a closing curly brace."
+                }
+                AstError::ListItemWithoutComma => "This list item should be followed by a comma.",
+                AstError::ListWithNonListItem => "This is not a list item.",
+                AstError::ListWithoutClosingParenthesis => {
+                    "This list doesn't have a closing parenthesis."
+                }
+                AstError::ParenthesizedWithoutClosingParenthesis => {
+                    "This expression is parenthesized, but the closing parenthesis is missing."
+                }
+                AstError::StructKeyWithoutColon => "This struct key should be followed by a colon.",
+                AstError::StructValueWithoutComma => {
+                    "This struct value should be followed by a comma."
+                }
+                AstError::StructWithNonStructField => "Structs should only contain struct key.",
+                AstError::StructWithoutClosingBrace => {
+                    "This struct doesn't have a closing bracket."
+                }
+                AstError::TextWithoutClosingQuote => "This text never ends.",
+                AstError::UnexpectedPunctuation => "This punctuation was unexpected.",
+            }
+            .to_string(),
+            CompilerErrorPayload::Hir(error) => match error {
+                HirError::NeedsWithWrongNumberOfArguments { num_args } => {
+                    format!("This `needs` is given {num_args} arguments, but it needs one or two – a condition and an optional reason.")
+                }
+                HirError::PublicAssignmentInNotTopLevel => {
+                    "This re-assigns a value that is public. That's not allowed.".to_string()
+                }
+                HirError::PublicAssignmentWithSameName { name } => {
+                    format!("There already exists a public assignment named `{name}`.")
+                }
+                HirError::UnknownReference { name } => {
+                    format!("Here, you reference `{name}`, but that name is not in scope.")
+                }
+            },
+        };
+        write!(f, "{message}")
+    }
+}

compiler/src/compiler/hir.rs

@@ -1,12 +1,15 @@
 use super::{ast_to_hir::AstToHir, error::CompilerError};
-use crate::{builtin_functions::BuiltinFunction, module::Module};
-use im::HashMap;
+use crate::{
+    builtin_functions::BuiltinFunction,
+    module::{Module, ModuleKind, Package},
+};
 use itertools::Itertools;
 use linked_hash_map::LinkedHashMap;
 use num_bigint::BigUint;
 use std::{
-    collections::HashSet,
+    collections::HashMap,
     fmt::{self, Display, Formatter},
+    hash,
     sync::Arc,
 };
 use tracing::info;
@@ -86,8 +89,8 @@ impl Expression {
             }
             Expression::Builtin(_) => {}
             Expression::Needs { condition, reason } => {
-                ids.push(*condition.clone());
-                ids.push(*reason.clone());
+                ids.push(condition.clone());
+                ids.push(reason.clone());
             }
             Expression::Error { .. } => {}
         }
@@ -112,6 +115,36 @@ impl Id {
         Self { module, keys }
     }
 
+    /// An ID that can be used to blame the tooling. For example, when calling
+    /// the `main` function, we want to be able to blame the platform for
+    /// passing a wrong environment.
+    fn tooling(name: String) -> Self {
+        Self {
+            module: Module {
+                package: Package::Tooling(name),
+                path: vec![],
+                kind: ModuleKind::Code,
+            },
+            keys: vec![],
+        }
+    }
+    pub fn platform() -> Self {
+        Self::tooling("platform".to_string())
+    }
+    pub fn fuzzer() -> Self {
+        Self::tooling("fuzzer".to_string())
+    }
+    /// TODO: Currently, when a higher-order function calls a closure passed as
+    /// a parameter, that's registered as a normal call instruction, making the
+    /// callsite in the higher-order function responsible for the successful
+    /// fulfillment of the passed function's `needs`. We probably want to change
+    /// how that works so that the caller of the higher-order function is at
+    /// fault when passing a panicking function. After we did that, we should be
+    /// able to remove this ID.
+    pub fn complicated_responsibility() -> Self {
+        Self::tooling("complicated-responsibility".to_string())
+    }
+
     pub fn is_root(&self) -> bool {
         self.keys.is_empty()
     }
@@ -138,7 +171,7 @@ impl Display for Id {
     }
 }
 
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum Expression {
     Int(BigUint),
     Text(String),
@@ -157,8 +190,8 @@ pub enum Expression {
         relative_path: Id,
     },
     Needs {
-        condition: Box<Id>,
-        reason: Box<Id>,
+        condition: Id,
+        reason: Id,
     },
     Error {
         child: Option<Id>,
@@ -170,41 +203,29 @@ impl Expression {
         Expression::Symbol("Nothing".to_string())
     }
 }
+#[allow(clippy::derive_hash_xor_eq)]
+impl hash::Hash for Expression {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        core::mem::discriminant(self).hash(state);
+    }
+}
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Lambda {
     pub parameters: Vec<Id>,
     pub body: Body,
     pub fuzzable: bool,
 }
-impl Lambda {
-    pub fn captured_ids(&self, my_id: &Id) -> Vec<Id> {
-        let mut captured = vec![];
-        self.body.collect_all_ids(&mut captured);
-        captured
-            .into_iter()
-            .filter(|potentially_captured_id| {
-                !my_id.is_same_module_and_any_parent_of(potentially_captured_id)
-            })
-            .collect::<HashSet<_>>()
-            .into_iter()
-            .collect_vec()
-    }
-}
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Body {
     pub expressions: LinkedHashMap<Id, Expression>,
     pub identifiers: HashMap<Id, String>,
 }
-impl Body {
-    #[allow(dead_code)]
-    pub fn return_value(&self) -> Id {
-        self.expressions
-            .keys()
-            .last()
-            .expect("no expressions")
-            .clone()
+#[allow(clippy::derive_hash_xor_eq)]
+impl hash::Hash for Body {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.expressions.hash(state);
     }
 }
 
@@ -329,7 +350,7 @@ impl fmt::Display for Lambda {
 }
 impl fmt::Display for Body {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for (id, expression) in self.expressions.iter() {
+        for (id, expression) in &self.expressions {
             writeln!(f, "{id} = {expression}")?;
         }
         Ok(())
@@ -355,7 +376,7 @@ impl Expression {
     }
 }
 impl Body {
-    fn find(&self, id: &Id) -> Option<&Expression> {
+    pub fn find(&self, id: &Id) -> Option<&Expression> {
         if let Some(expression) = self.expressions.get(id) {
             Some(expression)
         } else {