Add Dictionary::at()

Author: Bromeon

godot-core/src/builtin/dictionary.rs

@@ -100,26 +100,51 @@ impl Dictionary {
         }
     }
 
+    /// ⚠️ Returns the value for the given key, or panics.
+    ///
+    /// If you want to check for presence, use [`get()`][Self::get] or [`get_or_nil()`][Self::get_or_nil].
+    ///
+    /// # Panics
+    ///
+    /// If there is no value for the given key. Note that this is distinct from a `NIL` value, which is returned as `Variant::nil()`.
+    pub fn at<K: ToGodot>(&self, key: K) -> Variant {
+        // Code duplication with get(), to avoid third clone (since K: ToGodot takes ownership).
+
+        let key = key.to_variant();
+        if self.contains_key(key.clone()) {
+            self.get_or_nil(key)
+        } else {
+            panic!("key {key:?} missing in dictionary: {self:?}")
+        }
+    }
+
     /// Returns the value for the given key, or `None`.
     ///
     /// Note that `NIL` values are returned as `Some(Variant::nil())`, while absent values are returned as `None`.
-    /// If you want to treat both as `NIL`, use [`Self::get_or_nil`].
+    /// If you want to treat both as `NIL`, use [`get_or_nil()`][Self::get_or_nil].
+    ///
+    /// When you are certain that a key is present, use [`at()`][`Self::at`] instead.
+    ///
+    /// This can be combined with Rust's `Option` methods, e.g. `dict.get(key).unwrap_or(default)`.
     pub fn get<K: ToGodot>(&self, key: K) -> Option<Variant> {
+        // If implementation is changed, make sure to update at().
+
         let key = key.to_variant();
-        if !self.contains_key(key.clone()) {
-            return None;
+        if self.contains_key(key.clone()) {
+            Some(self.get_or_nil(key))
+        } else {
+            None
         }
-
-        Some(self.get_or_nil(key))
     }
 
     /// Returns the value at the key in the dictionary, or `NIL` otherwise.
     ///
     /// This method does not let you differentiate `NIL` values stored as values from absent keys.
-    /// If you need that, use [`Self::get`].
+    /// If you need that, use [`get()`][`Self::get`] instead.
+    ///
+    /// When you are certain that a key is present, use [`at()`][`Self::at`] instead.
     ///
     /// _Godot equivalent: `dict.get(key, null)`_
-    #[doc(alias = "get")]
     pub fn get_or_nil<K: ToGodot>(&self, key: K) -> Variant {
         self.as_inner().get(key.to_variant(), Variant::nil())
     }

itest/rust/src/builtin_tests/containers/dictionary_test.rs

@@ -165,29 +165,29 @@ fn dictionary_duplicate_shallow() {
         "foo": 0,
         "bar": subdictionary.clone()
     };
+
     let mut clone = dictionary.duplicate_shallow();
     Dictionary::from_variant(&clone.get("bar").unwrap()).insert("baz", 4);
     assert_eq!(
         subdictionary.get("baz"),
         Some(4.to_variant()),
         "key = \"baz\""
     );
+
     clone.insert("foo", false.to_variant());
     assert_eq!(dictionary.get("foo"), Some(0.to_variant()));
     assert_eq!(clone.get("foo"), Some(false.to_variant()));
 }
 
 #[itest]
 fn dictionary_get() {
-    let mut dictionary = dict! {
+    let dictionary = dict! {
         "foo": 0,
         "bar": true,
         "baz": "foobar",
         "nil": Variant::nil(),
     };
 
-    dictionary.insert("baz", "foobar");
-
     assert_eq!(dictionary.get("foo"), Some(0.to_variant()), "key = \"foo\"");
     assert_eq!(
         dictionary.get("bar"),
@@ -210,6 +210,26 @@ fn dictionary_get() {
     assert_eq!(dictionary.get("foobar"), None, "key = \"foobar\"");
 }
 
+#[itest]
+fn dictionary_at() {
+    let dictionary = dict! {
+        "foo": 0,
+        "baz": "foobar",
+        "nil": Variant::nil(),
+    };
+
+    assert_eq!(dictionary.at("foo"), 0.to_variant(), "key = \"foo\"");
+    assert_eq!(
+        dictionary.at("baz"),
+        "foobar".to_variant(),
+        "key = \"baz\""
+    );
+    assert_eq!(dictionary.at("nil"), Variant::nil(), "key = \"nil\"");
+    expect_panic("key = \"bar\"", || {
+        dictionary.at("bar");
+    });
+}
+
 #[itest]
 fn dictionary_insert() {
     let mut dictionary = dict! {