Add strict and optional as casts

Author: filipsajdak

include/cpp2util.h

@@ -626,6 +626,27 @@ auto as( X const* x ) -> C const* {
     return dynamic_cast<C const*>(x);
 }
 
+template <typename C, typename X>
+inline constexpr auto program_violates_strict_type_safety_guarantee =
+       std::is_same_v<C, X>
+    || requires (X x){ C{x}; }
+    || std::is_base_of_v<C, X>
+;
+
+template< typename C, typename T >
+auto strict_as(T&& t) -> auto {
+    static_assert(program_violates_strict_type_safety_guarantee<C, std::remove_cvref_t<T>>, "type cannot be safely cast - consider using optional cast '?' or throwing cast");
+    return cpp2::as<C>(std::forward<T>(t));
+}
+
+template< typename C, typename T >
+auto optional_as(T&& t) -> auto {
+    try {
+        return std::optional<C>{cpp2::as<C>(std::forward<T>(t))};
+    } catch(const cpp2::narrowing_error&) {
+        return std::optional<C>{};
+    }
+}
 
 //-------------------------------------------------------------------------------------------------------------
 //  std::variant is and as

source/cppfront.cpp

@@ -1906,7 +1906,33 @@ class cppfront
                 return;
             }
 
-            printer.print_cpp2("cpp2::as<", n.position());
+            bool add_strict_as = false;
+            bool add_optional_as = false;
+            if (auto* postfix = n.terms.front().expr->get_postfix_expression_node()){
+                if(auto* id_expr = std::get_if<primary_expression_node::id_expression>(&postfix->expr->expr)) {
+                    if (auto* unqual = std::get_if<id_expression_node::unqualified>(&(*id_expr)->id)) {
+                        if ((*unqual)->strict) {
+                            add_strict_as = true;
+                        } else if ((*unqual)->optional) {
+                            add_optional_as = true;
+                        }
+                    } else if (auto* qual = std::get_if<id_expression_node::qualified>(&(*id_expr)->id)){
+                        if ((*qual)->ids.back().id->strict) {
+                            add_strict_as = true;
+                        } else if ((*qual)->ids.back().id->optional) {
+                            add_optional_as = true;
+                        }
+                    }
+                }
+            }
+
+            if (add_strict_as) {
+                printer.print_cpp2("cpp2::strict_as<", n.position());
+            } else if (add_optional_as) {
+                printer.print_cpp2("cpp2::optional_as<", n.position());
+            } else {
+                printer.print_cpp2("cpp2::as<", n.position());
+            }
             emit(*n.terms.front().expr);
             printer.print_cpp2(">(", n.position());
 

source/parse.h

@@ -379,6 +379,8 @@ struct unqualified_id_node
         > arg;
     };
     std::vector<term> template_args;
+    token const* strict = {};  // optional
+    token const* optional = {};  // optional
 
     auto get_token() -> token const* {
         if (template_args.empty()) {
@@ -1836,6 +1838,14 @@ class parser
             next();
         }
 
+        if (curr().type() == lexeme::Not) {
+            n->strict =  &curr();
+            next();
+        } else if (curr().type() == lexeme::QuestionMark) {
+            n->optional =  &curr();
+            next();
+        }
+
         return n;
     }