Unify using syntax

I had been using the Cpp1 syntax since I had nothing substantially better. But that did leave the grammar divergence between

    using std::vector; // use one thing from std
    using namespace std; // use everything in std

But then I remembered the `_` wildcard, so with this change instead of `using namespace NNN ;` we write `using NNN::_ ;`. This makes them more consistent:

    using std::vector ; // use one thing from std
    using std::_ ; // use everything in std

Of course the latter still lowers to Cpp1 `using namespace std;`

Author: hsutter

docs/cpp2/declarations.md

@@ -208,7 +208,7 @@ chr    : namespace == std::chrono;
 chrlit : namespace == std::chrono_literals;
 
 main: () = {
-    using namespace chrlit;
+    using chrlit::_ ;
 
     //  The next two lines are equivalent
     std::cout << "1s is (std::chrono::nanoseconds(1s).count())$ns\n";

docs/cpp2/namespaces.md

@@ -20,11 +20,11 @@ main: () = {
 
 ## <a id="using"></a> `using`
 
-A `#!cpp using` statement brings names declared in another namespace into the current scope as if they had been declared in the current scope. It has two forms:
+A `#!cpp using` statement brings names declared in another namespace into the current scope as if they had been declared in the current scope.
 
-- `#!cpp using a_namespace::a_name;` brings the single name `a_name` into scope.
+`#!cpp using a_namespace::a_name ;` brings the single name `a_name` into scope.
 
-- `#!cpp using namespace a_namespace;` brings all the namespace's names into scope.
+`#!cpp using a_namespace::_ ;` brings all the namespace's names into scope using the `#!cpp _` wildcard.
 
 For example:
 
@@ -40,15 +40,15 @@ main: () = {
     w: widgetlib::widget = /*...*/;
 
     {
-        //  Using the name, no qualification needed
+        //  Using the specific name, no widgetlib:: qualification needed
         using widgetlib::widget;
         w2: widget = /*...*/;
         // ...
     }
 
     {
-        //  Using the whole namespace, no qualification needed
-        using namespace widgetlib;
+        //  Using the whole namespace, no widgetlib:: qualification needed
+        using widgetlib::_;
         w3: widget = /*...*/;
         // ...
     }

regression-tests/mixed-bugfix-for-literal-as-nttp.cpp2

@@ -1,6 +1,6 @@
 #include <chrono>
-using namespace std::chrono_literals;
 main: () = {
+  using std::chrono_literals::_ ;
   assert( 10 as i32 == 10 );
   assert( 10LL as i32 == 10 );
   assert( 10s as std::chrono::seconds == 10s );

regression-tests/pure2-print.cpp2

@@ -12,7 +12,7 @@ outer: @print type = {
         protected f: () -> int = 42;
 
         g: (virtual this, i:int) -> int = {
-            using namespace ::std;
+            using ::std::_ ;
 
             s := "string literal";
             ret: int = i;

regression-tests/test-results/gcc-10-c++20/mixed-type-safety-1.cpp.output

@@ -1,4 +1,4 @@
-/usr/bin/ld: /tmp/ccSlwpC6.o: in function `main':
+/usr/bin/ld: /tmp/ccoR2zYT.o: in function `main':
 mixed-type-safety-1.cpp:(.text+0x327): undefined reference to `void print<std::integral_constant<bool, false> >(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::integral_constant<bool, false> const&)'
 /usr/bin/ld: mixed-type-safety-1.cpp:(.text+0x388): undefined reference to `void print<std::integral_constant<bool, true> >(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::integral_constant<bool, true> const&)'
 /usr/bin/ld: mixed-type-safety-1.cpp:(.text+0x422): undefined reference to `void print<std::integral_constant<bool, true> >(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::integral_constant<bool, true> const&)'

regression-tests/test-results/mixed-bugfix-for-literal-as-nttp.cpp

@@ -12,15 +12,15 @@
 
 #line 1 "mixed-bugfix-for-literal-as-nttp.cpp2"
 #include <chrono>
-using namespace std::chrono_literals;
 auto main() -> int;
 
 //=== Cpp2 function definitions =================================================
 
 #line 1 "mixed-bugfix-for-literal-as-nttp.cpp2"
 
-#line 3 "mixed-bugfix-for-literal-as-nttp.cpp2"
+#line 2 "mixed-bugfix-for-literal-as-nttp.cpp2"
 auto main() -> int{
+  using namespace std::chrono_literals;
   if (cpp2::cpp2_default.is_active() && !(cpp2::impl::as_<cpp2::i32, 10>() == 10) ) { cpp2::cpp2_default.report_violation(""); }
   if (cpp2::cpp2_default.is_active() && !(cpp2::impl::as_<cpp2::i32, 10LL>() == 10) ) { cpp2::cpp2_default.report_violation(""); }
   if (cpp2::cpp2_default.is_active() && !(cpp2::impl::as_<std::chrono::seconds>(10s) == 10s) ) { cpp2::cpp2_default.report_violation(""); }

regression-tests/test-results/msvc-2022-c++latest/pure2-type-safety-1.cpp.output

@@ -1,7 +1,7 @@
 pure2-type-safety-1.cpp
 pure2-type-safety-1.cpp2(26): error C2666: 'print': overloaded functions have similar conversions
 pure2-type-safety-1.cpp2(29): note: could be 'void print(const std::string &,const bool)'
-C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Tools\MSVC\14.40.33807\include\print(125): note: or       'void std::print<std::false_type>(const std::basic_format_string<char,std::integral_constant<bool,false>>,std::false_type &&)' [found using argument-dependent lookup]
+C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.40.33807\include\print(125): note: or       'void std::print<std::false_type>(const std::basic_format_string<char,std::integral_constant<bool,false>>,std::false_type &&)' [found using argument-dependent lookup]
 pure2-type-safety-1.cpp2(26): note: while trying to match the argument list '(std::basic_string<char,std::char_traits<char>,std::allocator<char>>, std::false_type)'
 pure2-type-safety-1.cpp2(26): note: the template instantiation context (the oldest one first) is
 pure2-type-safety-1.cpp2(8): note: see reference to function template instantiation 'void test_generic<double,char[7]>(const _T0 &,const _T1 (&))' being compiled

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.7.3   Build 9817:1821
+cppfront compiler v0.7.3   Build 9821:0915
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"9817:1821"
+"9821:0915"

source/parse.h

@@ -2107,9 +2107,15 @@ struct jump_statement_node
 struct using_statement_node
 {
     token const*                        keyword = {};
-    bool                                for_namespace = false;
     std::unique_ptr<id_expression_node> id;
 
+    auto for_namespace() const
+        -> bool
+    {
+        assert(id);
+        return id->to_string().ends_with("::_");
+    }
+
     auto position() const
         -> source_position
     {
@@ -5183,11 +5189,16 @@ auto pretty_print_visualize(using_statement_node const& n, int indent)
 
     auto ret = std::string{"\n"} + pre(indent) + n.keyword->as_string_view() + " ";
 
-    if (n.for_namespace) {
+    if (n.for_namespace()) {
         ret += "namespace ";
     }
 
     ret += pretty_print_visualize(*n.id, indent);
+    if (n.for_namespace()) {
+        assert(ret.ends_with("::_"));
+        ret.resize( ret.size() - 3 );   // maybe someday: ret.remove_suffix(3)
+    }
+
     if (ret.back() != ';') {
         ret += ";";
     }
@@ -7705,7 +7716,7 @@ class parser
 
     //G using-statement:
     //G     'using' qualified-id ';'
-    //G     'using' 'namespace' id-expression ';'
+    //G     'using' id-expression '::' '_' ';'
     //G
     auto using_statement()
         -> std::unique_ptr<using_statement_node>
@@ -7715,26 +7726,31 @@ class parser
         if (curr() != "using") {
             return {};
         }
-        n->keyword = &curr();
-        next();
 
-        if (curr() == "namespace") {
-            n->for_namespace = true;
-            next();
+        if (
+            peek(1) 
+            && *peek(1) == "namespace"
+            )
+        {
+            error("in Cpp2, write 'using the_namespace_name::_' to bring all names in the namespace into scope using the '_' wildcard");
+            return {};
         }
 
+        n->keyword = &curr();
+        next();
+
         auto id = id_expression();
         if (!id) {
-            error(std::string{"expected valid id-expression after 'using"} + (n->for_namespace ? " namespace" : "") + "'");
+            error(std::string{"expected valid id-expression after 'using"} + (n->for_namespace() ? " namespace" : "") + "'");
             return {};
         }
-        if (!n->for_namespace && !id->is_qualified()) {
-            error("'using' for a specific name (not 'using namespace') must specify a qualified name", false);
+        n->id = std::move(id);
+
+        if (!n->for_namespace() && !n->id->is_qualified()) {
+            error("'using' must specify a qualified name", false);
             return {};
         }
 
-        n->id = std::move(id);
-
         if (curr().type() != lexeme::Semicolon) {
             error("expected ; at end of using-statement");
             return {};
@@ -9647,7 +9663,7 @@ class parse_tree_printer : printing_visitor
 
     auto start(using_statement_node const& n, int indent) -> void
     {
-        o << pre(indent) << "using" << (n.for_namespace? " namespace" : "") << "\n";
+        o << pre(indent) << "using" << (n.for_namespace()? " namespace" : "") << "\n";
     }
 
     auto start(inspect_expression_node const& n, int indent) -> void