[WIP] Lushui panic is not Rust panic

Author: fmease

compiler/codegen_llvm/src/lib.rs

@@ -294,6 +294,7 @@ impl<'a, 'ctx> Generator<'a, 'ctx> {
             }
             Substituted(_) => todo!(),
             IO(_) => todo!(),
+            Panic(_) => todo!(),
             Error => todo!(),
         }
     }
@@ -341,6 +342,7 @@ impl<'a, 'ctx> Generator<'a, 'ctx> {
             IntrinsicApplication(_) => todo!(),
             Projection(_) => todo!(),
             IO(_) => todo!(),
+            Panic(_) => todo!(),
             // @Question how should we handle that?
             Error => todo!(),
         };
@@ -407,6 +409,7 @@ impl<'a, 'ctx> Generator<'a, 'ctx> {
             IntrinsicApplication(_) => todo!(),
             Projection(_) => todo!(),
             IO(_) => todo!(),
+            Panic(_) => todo!(),
             Error => todo!(),
         }
     }
@@ -451,6 +454,7 @@ impl ExpressionExt for hir::Expression {
             Substituted(_) => todo!(),
             Projection(_) => todo!(),
             IO(_) => todo!(),
+            Panic(_) => todo!(),
             Error => todo!(),
         }
     }

compiler/hir/src/interfaceable.rs

@@ -32,10 +32,15 @@ pub enum Value {
         type_: Type,
         value: Option<Box<Value>>,
     },
+    // @Task rename to Effect
     IO {
         index: usize,
         arguments: Vec<Value>,
     },
+    // @Task make this an effect
+    Panic {
+        message: String,
+    },
     Opaque(()),
 }
 

compiler/hir/src/intrinsic.rs

@@ -165,7 +165,7 @@ pub fn functions() -> HashMap<Function, FunctionValue> {
     );
     intrinsics.insert(
         Panic,
-        pure!(|_type: Opaque, message: Text| panic!("{message}")),
+        pure!(|_type: Opaque, message: Text| Value::Panic { message }),
     );
 
     intrinsics

compiler/hir/src/lib.rs

@@ -118,7 +118,10 @@ pub enum BareExpression {
     Substituted(Box<Substituted>),
     IntrinsicApplication(Box<IntrinsicApplication>),
     Projection(Box<Projection>),
+    // @Task rename to Effect
     IO(Box<IO>),
+    // @Task make this an effect
+    Panic(Box<Panic>),
     Error,
 }
 
@@ -249,6 +252,18 @@ impl From<IO> for BareExpression {
     }
 }
 
+#[derive(Clone, Debug)]
+// @Temporary
+pub struct Panic {
+    pub message: String,
+}
+
+impl From<Panic> for BareExpression {
+    fn from(panic: Panic) -> Self {
+        Self::Panic(Box::new(panic))
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct Case {
     pub pattern: Pattern,

compiler/hir_format/src/lib.rs

@@ -243,6 +243,8 @@ fn write_lower_expression(
             }
             write!(f, ")")
         }
+        // @Temporary, @Task just write it out as an application of `panic`
+        Panic(panic) => write!(f, "?(panic {:?})", panic.message),
         Substituted(substituted) => {
             write!(f, "?(substituted ",)?;
             substituted.substitution.write(context, f)?;

compiler/server/src/lib.rs

@@ -474,6 +474,7 @@ impl FindBinding for hir::Expression {
             IntrinsicApplication(_) => None, // @Task
             Projection(_) => None,           // @Task
             IO(_) => None,                   // @Task
+            Panic(_) => None,                // @Task
             Error => None,                   // @Task
         }
     }

compiler/session/src/lib.rs

@@ -472,6 +472,9 @@ impl InterfaceableBindingExt for interfaceable::Value {
                 }
                 .into(),
             ),
+            Self::Panic { message } => {
+                Expression::new(default(), default(), hir::Panic { message }.into())
+            }
             Self::Opaque(()) => unreachable!(),
         })
     }

compiler/typer/src/interpreter.rs

@@ -93,7 +93,7 @@ impl<'a> Interpreter<'a> {
             // @Task verify
             (Projection(_), _) => expression,
             // @Temporary
-            (IO(_), _) => expression,
+            (IO(_), _) | (Panic(_), _) => expression,
             (Application(application), substitution) => Expression::new(
                 expression.attributes,
                 expression.span,
@@ -415,6 +415,9 @@ impl<'a> Interpreter<'a> {
                 }
             }
             Type | Number(_) | Text(_) | IO(_) => expression,
+            // @Task smh add a backtrace here!
+            // @Task make sure that ?(panic _) is evaluated *eagerly* not lazily!
+            Panic(_) => expression,
             Projection(_) => todo!(),
             PiType(pi) => match context.form {
                 Form::Normal => {
@@ -616,34 +619,25 @@ impl<'a> Interpreter<'a> {
         binder: Identifier,
         arguments: Vec<Expression>,
     ) -> Result<Option<Expression>> {
-        eprintln!("apply_intrinsic_function binder={binder} args=[{arguments:?}]");
-
         match self.look_up(binder.declaration_index().unwrap()).kind {
             hir::EntityKind::IntrinsicFunction {
                 arity, function, ..
             } => Ok(if arguments.len() == arity {
-                eprintln!("  look_up -> [entity] intrinsic function");
-
                 let mut value_arguments = Vec::new();
 
                 // @Task tidy up with iterator combinators
                 for argument in arguments {
-                    dbg!(&argument);
-
                     if let Some(argument) =
                         interfaceable::Value::from_expression(&argument, self.session)
                     {
-                        eprintln!("interfaceable argument found, pushing ...");
                         value_arguments.push(argument);
                     } else {
-                        eprintln!("non-interfaceable argument found, aborting ...");
                         return Ok(None);
                     }
                 }
 
                 Some(function(value_arguments).into_expression(self.session)?)
             } else {
-                eprintln!("  look_up -> None");
                 None
             }),
             _ => unreachable!(),

compiler/typer/src/lib.rs

@@ -768,6 +768,8 @@ expected type ‘_ -> _’
             IO(_) => self
                 .session
                 .look_up_intrinsic_type(intrinsic::Type::IO, Some(expression.span))?,
+            // @Task this should be of any type, it is should be a (flexible) inference variable
+            Panic(_) => todo!(),
             Error => expression,
         })
     }