fix compiler crash when assigning to non-assignable expression

trilogy-ir/src/error.rs

···
         name: ir::Identifier,
         assignment: Span,
     },
+    InvalidAssignmentTarget {
+        target: Span,
+    },
     DuplicateExport {
         original: Span,
         duplicate: syntax::Identifier,
···
             Error::DuplicateDefinition { .. } => write!(f, "duplicate definition"),
             Error::IdentifierInOwnDefinition { .. } => write!(f, "identifier in own definition"),
             Error::AssignedImmutableBinding { .. } => write!(f, "assigned immutable binding"),
+            Error::InvalidAssignmentTarget { .. } => write!(f, "invalid assignment target"),
             Error::DuplicateExport { .. } => write!(f, "duplicate export"),
             Error::BecomeOutsideHandlerContext { .. } => {
                 write!(f, "become used outside of handler")

trilogy-ir/src/ir/assignment.rs

···
 
         let op = match ast.strategy {
             Direct(..) => {
-                if let expression::Value::Reference(id) = &lhs.value
-                    && !id.is_mutable
-                {
-                    converter.error(Error::AssignedImmutableBinding {
-                        name: *id.clone(),
-                        assignment: span,
-                    });
+                match &lhs.value {
+                    expression::Value::Reference(id) => {
+                        if !id.is_mutable {
+                            converter.error(Error::AssignedImmutableBinding {
+                                name: *id.clone(),
+                                assignment: span,
+                            });
+                        }
+                    }
+                    expression::Value::Application(app) => match &app.function.value {
+                        expression::Value::Application(app_fn)
+                            if matches!(app_fn.function.value, Value::Builtin(Builtin::Access)) => {
+                        }
+                        _ => {
+                            converter.error(Error::InvalidAssignmentTarget { target: lhs.span });
+                        }
+                    },
+                    _ => {
+                        converter.error(Error::InvalidAssignmentTarget { target: lhs.span });
+                    }
                 }
                 return Expression::assignment(span, Assignment { lhs, rhs });
             }

trilogy/src/trilogy/builder/report.rs

···
                                 name.id.name(),
                             ))
                     }
+                    Error::InvalidAssignmentTarget { target } => {
+                        let span = cache.span(location, *target);
+                        ariadne::Report::build(kind, span.clone())
+                            .with_message("invalid assignment target")
+                            .with_label(
+                                Label::new(span)
+                                    .with_color(primary)
+                                    .with_message("this expression is not assignable")
+                                    .with_order(1),
+                            )
+                            .with_help("only single identifiers or member access expressions (`.`) can be assigned to")
+                    }
                     Error::GluePatternMissingLiteral { lhs, glue, rhs } => {
                         let lhs = cache.span(location, *lhs);
                         let glue = cache.span(location, *glue);