Fix Conformance Test Failures in Qualified Identifier Resolution

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "cel-spec"]
+	path = cel-spec
+	url = https://github.com/google/cel-spec.git

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["cel", "example", "fuzz"]
+members = ["cel", "example", "fuzz", "conformance"]
 resolver = "2"
 
 [profile.bench]

cel/Cargo.toml

@@ -36,4 +36,5 @@ default = ["regex", "chrono"]
 json = ["dep:serde_json", "dep:base64"]
 regex = ["dep:regex"]
 chrono = ["dep:chrono"]
+proto = []  # Proto feature for conformance tests
 dhat-heap = [ ] # if you are doing heap profiling

cel/src/common/ast/mod.rs

@@ -68,6 +68,10 @@ pub struct SelectExpr {
     pub operand: Box<IdedExpr>,
     pub field: String,
     pub test: bool,
+    /// is_extension indicates whether the field access uses protobuf extension syntax.
+    /// Extension fields are accessed using msg.(ext.field) syntax where the parentheses
+    /// indicate an extension field lookup.
+    pub is_extension: bool,
 }
 
 #[derive(Clone, Debug, Default, PartialEq)]

cel/src/context.rs

@@ -1,3 +1,4 @@
+use crate::extensions::ExtensionRegistry;
 use crate::magic::{Function, FunctionRegistry, IntoFunction};
 use crate::objects::{TryIntoValue, Value};
 use crate::parser::Expression;
@@ -35,11 +36,14 @@ pub enum Context<'a> {
         functions: FunctionRegistry,
         variables: BTreeMap<String, Value>,
         resolver: Option<&'a dyn VariableResolver>,
+        extensions: ExtensionRegistry,
+        container: Option<String>,
     },
     Child {
         parent: &'a Context<'a>,
         variables: BTreeMap<String, Value>,
         resolver: Option<&'a dyn VariableResolver>,
+        container: Option<String>,
     },
 }
 
@@ -100,6 +104,7 @@ impl<'a> Context<'a> {
                 variables,
                 parent,
                 resolver,
+                container,
             } => resolver
                 .and_then(|r| r.resolve(name))
                 .or_else(|| {
@@ -108,23 +113,140 @@ impl<'a> Context<'a> {
                         .cloned()
                         .or_else(|| parent.get_variable(name).ok())
                 })
+                .or_else(|| {
+                    // Try qualified name resolution with container
+                    if let Some(container_name) = container {
+                        self.try_qualified_lookup(name, container_name, variables, Some(parent))
+                    } else {
+                        None
+                    }
+                })
                 .ok_or_else(|| ExecutionError::UndeclaredReference(name.to_string().into())),
             Context::Root {
                 variables,
                 resolver,
+                container,
                 ..
             } => resolver
                 .and_then(|r| r.resolve(name))
                 .or_else(|| variables.get(name).cloned())
+                .or_else(|| {
+                    // Try qualified name resolution with container
+                    if let Some(container_name) = container {
+                        self.try_qualified_lookup(name, container_name, variables, None)
+                    } else {
+                        None
+                    }
+                })
                 .ok_or_else(|| ExecutionError::UndeclaredReference(name.to_string().into())),
         }
     }
 
-    pub(crate) fn get_function(&self, name: &str) -> Option<&Function> {
+    /// Attempts to resolve a variable name using qualified name resolution.
+    ///
+    /// According to the CEL spec, when a container is set, identifiers should be resolved
+    /// by trying progressively shorter prefixes. For example, if the container is "a.b.c"
+    /// and we're looking for identifier "x", we should try:
+    /// 1. "x" (already tried in get_variable)
+    /// 2. "a.b.c.x"
+    /// 3. "a.b.x"
+    /// 4. "a.x"
+    fn try_qualified_lookup(
+        &self,
+        name: &str,
+        container: &str,
+        variables: &BTreeMap<String, Value>,
+        parent: Option<&Context<'_>>,
+    ) -> Option<Value> {
+        // Build a list of candidate names to try
+        let mut candidates = Vec::new();
+
+        // Add the fully qualified name
+        candidates.push(format!("{}.{}", container, name));
+
+        // Add progressively shorter prefixes
+        let parts: Vec<&str> = container.split('.').collect();
+        for i in (1..parts.len()).rev() {
+            let prefix = parts[..i].join(".");
+            candidates.push(format!("{}.{}", prefix, name));
+        }
+
+        // Try each candidate
+        for candidate in candidates {
+            // Check in current context's variables
+            if let Some(value) = variables.get(&candidate) {
+                return Some(value.clone());
+            }
+
+            // Check in parent context if available
+            if let Some(parent) = parent {
+                if let Ok(value) = parent.get_variable(&candidate) {
+                    return Some(value);
+                }
+            }
+        }
+
+        None
+    }
+
+    pub fn get_extension_registry(&self) -> Option<&ExtensionRegistry> {
         match self {
+            Context::Root { extensions, .. } => Some(extensions),
+            Context::Child { parent, .. } => parent.get_extension_registry(),
+        }
+    }
+
+    pub fn get_extension_registry_mut(&mut self) -> Option<&mut ExtensionRegistry> {
+        match self {
+            Context::Root { extensions, .. } => Some(extensions),
+            Context::Child { .. } => None,
+        }
+    }
+
+    pub(crate) fn get_function(&self, name: &str) -> Option<&Function> {
+        // First try direct lookup
+        let direct = match self {
             Context::Root { functions, .. } => functions.get(name),
             Context::Child { parent, .. } => parent.get_function(name),
+        };
+
+        if direct.is_some() {
+            return direct;
+        }
+
+        // Try qualified name resolution with container
+        let container_name = self.get_container()?;
+
+        // Build a list of candidate names to try
+        let mut candidates = Vec::new();
+
+        // Add the fully qualified name
+        candidates.push(format!("{}.{}", container_name, name));
+
+        // Add progressively shorter prefixes
+        let parts: Vec<&str> = container_name.split('.').collect();
+        for i in (1..parts.len()).rev() {
+            let prefix = parts[..i].join(".");
+            candidates.push(format!("{}.{}", prefix, name));
+        }
+
+        // Try each candidate
+        for candidate in &candidates {
+            match self {
+                Context::Root { functions, .. } => {
+                    if let Some(func) = functions.get(candidate) {
+                        return Some(func);
+                    }
+                }
+                Context::Child { parent, .. } => {
+                    if let Some(func) = parent.get_function(candidate) {
+                        return Some(func);
+                    }
+                }
+            }
         }
+
+        None
     }
 
     pub fn add_function<T: 'static, F>(&mut self, name: &str, value: F)
@@ -149,6 +271,28 @@ impl<'a> Context<'a> {
             parent: self,
             variables: Default::default(),
             resolver: None,
+            container: None,
+        }
+    }
+
+    pub fn with_container(mut self, container: String) -> Self {
+        match &mut self {
+            Context::Root { container: c, .. } => {
+                *c = Some(container);
+            }
+            Context::Child { container: c, .. } => {
+                *c = Some(container);
+            }
+        }
+        self
+    }
+
+    pub fn get_container(&self) -> Option<&str> {
+        match self {
+            Context::Root { container, .. } => container.as_deref(),
+            Context::Child { container, parent, .. } => {
+                container.as_deref().or_else(|| parent.get_container())
+            }
         }
     }
 
@@ -168,6 +312,8 @@ impl<'a> Context<'a> {
             variables: Default::default(),
             functions: Default::default(),
             resolver: None,
+            extensions: ExtensionRegistry::new(),
+            container: None,
         }
     }
 }
@@ -178,6 +324,8 @@ impl Default for Context<'_> {
             variables: Default::default(),
             functions: Default::default(),
             resolver: None,
+            extensions: ExtensionRegistry::new(),
+            container: None,
         };
 
         ctx.add_function("contains", functions::contains);
@@ -189,6 +337,7 @@ impl Default for Context<'_> {
         ctx.add_function("string", functions::string);
         ctx.add_function("bytes", functions::bytes);
         ctx.add_function("double", functions::double);
+        ctx.add_function("float", functions::float);
         ctx.add_function("int", functions::int);
         ctx.add_function("uint", functions::uint);
         ctx.add_function("optional.none", functions::optional_none);