Add get_optional method to maps.

This returns an optional either containing the map's element for the
given key if that entry exists, or an unset optional if it does not.

Closes #1608.

(Note that we cannot use the same, improved implementation for the
existing `get()` method because that needs to return a reference.)

doc/autogen/types/map.rst

@@ -10,6 +10,11 @@
     exist, returns the default value if provided; otherwise throws a
     runtime error.
 
+.. spicy:method:: map::get_optional map get_optional False optional<type~of~element> (key: <any>)
+
+    Returns an optional either containing the map's element for the given
+    key if that entry exists, or an unset optional if it does not.
+
 .. rubric:: Operators
 
 .. spicy:operator:: map::Begin <iterator> begin(<container>)

hilti/runtime/include/types/map.h

@@ -222,6 +222,19 @@ class Map : protected std::map<K, V> {
         }
     }
 
+    /**
+     * Attempts to get the value for a key.
+     *
+     * @param k key to retrieve
+     * @return the value, or an unset optional if the key is not set in the map
+     */
+    std::optional<V> get_optional(const K& k) const& {
+        if ( auto it = this->find(k); it != static_cast<const M&>(*this).end() )
+            return it->second;
+        else
+            return {};
+    }
+
     /** Access an element by key
      *
      * @param k key of the element

hilti/toolchain/include/ast/forward.h

@@ -281,6 +281,7 @@ class IndexConst;
 class IndexNonConst;
 class IndexAssign;
 class Get;
+class GetOptional;
 class Clear;
 
 } // namespace map

hilti/toolchain/include/ast/node-tag.h

@@ -294,6 +294,7 @@ constexpr Tag IndexConst = 1906;
 constexpr Tag IndexNonConst = 1907;
 constexpr Tag Size = 1908;
 constexpr Tag Unequal = 1909;
+constexpr Tag GetOptional = 1910;
 
 namespace iterator {
 constexpr Tag Deref = 2000;

hilti/toolchain/include/ast/operators/map.h

@@ -23,6 +23,7 @@ HILTI_NODE_OPERATOR(map, IndexConst)
 HILTI_NODE_OPERATOR(map, IndexNonConst)
 HILTI_NODE_OPERATOR(map, IndexAssign)
 HILTI_NODE_OPERATOR(map, Get)
+HILTI_NODE_OPERATOR(map, GetOptional)
 HILTI_NODE_OPERATOR(map, Clear)
 
 } // namespace hilti::operator_

hilti/toolchain/include/ast/visitor-dispatcher.h

@@ -220,6 +220,7 @@ class Dispatcher {
     virtual void operator()(hilti::operator_::map::IndexNonConst* n) {}
     virtual void operator()(hilti::operator_::map::IndexAssign* n) {}
     virtual void operator()(hilti::operator_::map::Get* n) {}
+    virtual void operator()(hilti::operator_::map::GetOptional* n) {}
     virtual void operator()(hilti::operator_::map::Clear* n) {}
     virtual void operator()(hilti::operator_::network::Equal* n) {}
     virtual void operator()(hilti::operator_::network::Unequal* n) {}

hilti/toolchain/src/ast/operators/map.cc

@@ -355,6 +355,36 @@ the default value if provided; otherwise throws a runtime error.
 };
 HILTI_OPERATOR_IMPLEMENTATION(Get);
 
+class GetOptional : public BuiltInMemberCall {
+public:
+    Signature signature(Builder* builder) const final {
+        return Signature{
+            .kind = Kind::MemberCall,
+            .self = {parameter::Kind::In, builder->typeMap(type::Wildcard())},
+            .member = "get_optional",
+            .param0 =
+                {
+                    .name = "key",
+                    .type = {parameter::Kind::In, builder->typeAny()},
+                },
+            .result_doc = "optional<type of element>",
+            .ns = "map",
+            .doc = R"(
+Returns an optional either containing the map's element for the given key if
+that entry exists, or an unset optional if it does not.
+)",
+        };
+    }
+
+    QualifiedType* result(Builder* builder, const Expressions& operands, const Meta& meta) const final {
+        return builder->qualifiedType(builder->typeOptional(operands[0]->type()->type()->as<type::Map>()->valueType()),
+                                      Constness::Const);
+    }
+
+    HILTI_OPERATOR(hilti, map::GetOptional);
+};
+HILTI_OPERATOR_IMPLEMENTATION(GetOptional);
+
 class Clear : public BuiltInMemberCall {
 public:
     Signature signature(Builder* builder) const final {

hilti/toolchain/src/compiler/codegen/operators.cc

@@ -423,12 +423,17 @@ struct Visitor : hilti::visitor::PreOrder {
 
         if ( auto default_ = optionalArgument(args, 1); ! default_.empty() )
             result = fmt(
-                "[](auto&& m, auto&& k, auto&& default_) { return m.contains(k)? m.get(k) : default_; }(%s, %s, %s)",
+                "[](auto&& m, auto&& k, auto&& default_) { return m.contains(k) ? m.get(k) : default_; }(%s, %s, %s)",
                 self, k, default_);
         else
             result = fmt("%s.get(%s)", self, k);
     }
 
+    void operator()(operator_::map::GetOptional* n) final {
+        auto [self, args] = methodArguments(n);
+        result = fmt("%s.get_optional(%s)", self, args[0]);
+    }
+
     void operator()(operator_::map::IndexAssign* n) final {
         const auto& map = op0(n);
         const auto& key = op1(n);

tests/Baseline/spicy.types.map.ops/output

@@ -4,3 +4,5 @@ BBB
 0
 43
 43
+[$i=43]
+(not set)

tests/spicy/types/map/ops.spicy

@@ -36,3 +36,6 @@ u.i = 42;
 global m2 = map<string, U>("foo": u);
 m2["foo"].i = 43;
 print m2["foo"].i;
+
+print m2.get_optional("foo");
+print m2.get_optional("bar");