Do not construct backtrace for opt (#5198)

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

vortex-expr/src/expression.rs

@@ -79,12 +79,12 @@ impl Expression {
     ///
     /// Panics if the expression's encoding or metadata cannot be cast to the specified vtable.
     pub fn as_<V: VTable>(&self) -> ExpressionView<'_, V> {
-        ExpressionView::try_new(self).vortex_expect("Failed to downcast expression {} to {}")
+        ExpressionView::maybe_new(self).vortex_expect("Failed to downcast expression {} to {}")
     }
 
     /// Returns a typed view of this expression for the given vtable, if the types match.
     pub fn as_opt<V: VTable>(&self) -> Option<ExpressionView<'_, V>> {
-        ExpressionView::try_new(self).ok()
+        ExpressionView::maybe_new(self)
     }
 
     /// Returns the expression ID.

vortex-expr/src/view.rs

@@ -1,17 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::any::type_name;
 use std::ops::Deref;
 
-use vortex_error::{VortexExpect, VortexResult, vortex_err};
+use vortex_error::VortexExpect;
 
 use crate::{Expression, VTable};
 
 /// A view over an [`Expression`] with an associated vtable, allowing typed access to the
 /// expression's instance data.
 pub struct ExpressionView<'a, V: VTable> {
     expression: &'a Expression,
+    vtable: &'a V,
     data: &'a V::Instance,
 }
 
@@ -23,35 +23,29 @@ impl<'a, V: VTable> ExpressionView<'a, V> {
     /// Panics if the expression cannot be downcast to the specified vtable type.
     #[inline]
     pub fn new(expression: &'a Expression) -> Self {
-        Self::try_new(expression).vortex_expect("Failed to downcast expression")
+        Self::maybe_new(expression).vortex_expect("Failed to downcast expression")
     }
 
     /// Attempts to wrap up the given expression as an [`ExpressionView`] of the specified vtable type.
     #[inline]
-    pub fn try_new(expression: &'a Expression) -> VortexResult<Self> {
-        expression.vtable().as_opt::<V>().ok_or_else(|| {
-            vortex_err!(
-                "Failed to downcast {} to {}",
-                expression.id(),
-                type_name::<V>()
-            )
-        })?;
-
-        let data = expression
-            .data()
-            .downcast_ref::<V::Instance>()
-            .ok_or_else(|| {
-                vortex_err!(
-                    "Failed to downcast expression instance data to expected type {}",
-                    type_name::<V::Instance>()
-                )
-            })?;
-
-        Ok(Self { expression, data })
+    pub fn maybe_new(expression: &'a Expression) -> Option<Self> {
+        let vtable = expression.vtable().as_opt::<V>()?;
+        let data = expression.data().downcast_ref::<V::Instance>()?;
+        Some(Self {
+            expression,
+            vtable,
+            data,
+        })
     }
 }
 
 impl<'a, V: VTable> ExpressionView<'a, V> {
+    /// Returns the vtable for this expression.
+    #[inline(always)]
+    pub fn vtable(&self) -> &'a V {
+        self.vtable
+    }
+
     /// Returns the instance data for this expression.
     #[inline(always)]
     pub fn data(&self) -> &'a V::Instance {