fixes

Signed-off-by: Shaobo He <[email protected]>

Author: shaobo-he-aws

cedar-policy-core/src/ast/expr.rs

@@ -995,8 +995,8 @@ impl<T: Default + Clone> expr_builder::ExprBuilder for ExprBuilder<T> {
         }
     }
 
-    fn with_source_loc(mut self, maybe_source_loc: &Loc) -> Self {
-        self.source_loc = Some(maybe_source_loc.clone());
+    fn with_source_loc(mut self, source_loc: &Loc) -> Self {
+        self.source_loc = Some(source_loc.clone());
         self
     }
 

cedar-policy-core/src/ast/restricted_expr.rs

@@ -87,8 +87,8 @@ impl RestrictedExpr {
     }
 
     /// Return the `RestrictedExpr`, but with the new `source_loc` (or `None`).
-    pub fn with_source_loc(self, source_loc: Loc) -> Self {
-        Self(self.0.with_maybe_source_loc(Some(source_loc)))
+    pub fn with_maybe_source_loc(self, source_loc: Option<Loc>) -> Self {
+        Self(self.0.with_maybe_source_loc(source_loc))
     }
 
     /// Create a `RestrictedExpr` that's just a single `Literal`.
@@ -240,10 +240,7 @@ impl RestrictedExpr {
 
 impl From<Value> for RestrictedExpr {
     fn from(value: Value) -> RestrictedExpr {
-        match value.loc {
-            Some(loc) => RestrictedExpr::from(value.value).with_source_loc(loc),
-            None => RestrictedExpr::from(value.value),
-        }
+        RestrictedExpr::from(value.value).with_maybe_source_loc(value.loc)
     }
 }
 

cedar-policy-core/src/validator/schema/namespace_def.rs

@@ -958,10 +958,13 @@ impl<T: 'static> WithUnresolvedCommonTypeRefs<T> {
         f: impl FnOnce(T) -> U + 'static,
     ) -> WithUnresolvedCommonTypeRefs<U> {
         match self {
-            Self::WithUnresolved(resolve_func, loc) => WithUnresolvedCommonTypeRefs::new(
-                move |common_type_defs| resolve_func(common_type_defs).map(f),
-                loc,
-            ),
+            Self::WithUnresolved(_, ref loc) => {
+                let loc = loc.clone();
+                WithUnresolvedCommonTypeRefs::new(
+                    |common_type_defs| self.resolve_common_type_refs(common_type_defs).map(f),
+                    loc,
+                )
+            }
             Self::WithoutUnresolved(v, loc) => {
                 WithUnresolvedCommonTypeRefs::WithoutUnresolved(f(v), loc)
             }