Removed ban on using the name of a type scope name elsewhere in a type

See #1373

The programmer can always write `this.` to disambiguate. This originally seemed like a useful constraint, but it creates a tension between generated code and user code. For example, see #1373, and the example

    foo : @enum type = { s; }

which before this commit was rejected because the `@enum` type metafunction generates a function with a parameter named `s`.

It seems undesirable to force generated code to uglify its names to avoid conflicts.

Also, fix `@enum` for cases like this to type-scope-qualify access to the member.

Author: hsutter

regression-tests/test-results/pure2-enum.cpp

@@ -161,12 +161,12 @@ constexpr auto skat_game::operator=(skat_game&& that) noexcept -> skat_game& {
 [[nodiscard]] auto skat_game::to_string_impl(cpp2::impl::in<std::string_view> prefix) const& -> std::string{
 
 auto pref {cpp2::to_string(prefix)}; 
-if ((*this) == diamonds) {return pref + "diamonds"; }
-if ((*this) == hearts) {return pref + "hearts"; }
-if ((*this) == spades) {return pref + "spades"; }
-if ((*this) == clubs) {return pref + "clubs"; }
-if ((*this) == grand) {return pref + "grand"; }
-if ((*this) == null) {return cpp2::move(pref) + "null"; }
+if ((*this) == skat_game::diamonds) {return pref + "diamonds"; }
+if ((*this) == skat_game::hearts) {return pref + "hearts"; }
+if ((*this) == skat_game::spades) {return pref + "spades"; }
+if ((*this) == skat_game::clubs) {return pref + "clubs"; }
+if ((*this) == skat_game::grand) {return pref + "grand"; }
+if ((*this) == skat_game::null) {return cpp2::move(pref) + "null"; }
 return "invalid skat_game value"; 
 }
 
@@ -175,16 +175,16 @@ return "invalid skat_game value";
 [[nodiscard]] auto skat_game::from_string(cpp2::impl::in<std::string_view> s) -> skat_game{
 
 auto x {s}; 
-if ("diamonds" == x) {return diamonds; }
-else {if ("hearts" == x) {return hearts; }
-else {if ("spades" == x) {return spades; }
-else {if ("clubs" == x) {return clubs; }
-else {if ("grand" == x) {return grand; }
-else {if ("null" == cpp2::move(x)) {return null; }
+if ("diamonds" == x) {return skat_game::diamonds; }
+else {if ("hearts" == x) {return skat_game::hearts; }
+else {if ("spades" == x) {return skat_game::spades; }
+else {if ("clubs" == x) {return skat_game::clubs; }
+else {if ("grand" == x) {return skat_game::grand; }
+else {if ("null" == cpp2::move(x)) {return skat_game::null; }
 #line 1 "pure2-enum.cpp2"
 }}}}}
 CPP2_UFCS(report_violation)(cpp2::type_safety, CPP2_UFCS(c_str)(("can't convert string '" + cpp2::to_string(s) + "' to enum of type skat_game")));
-return diamonds; 
+return skat_game::diamonds; 
 }
 
 [[nodiscard]] auto skat_game::from_code(cpp2::impl::in<std::string_view> s) -> skat_game{
@@ -223,8 +223,8 @@ constexpr auto janus::operator=(janus&& that) noexcept -> janus& {
 [[nodiscard]] auto janus::to_string_impl(cpp2::impl::in<std::string_view> prefix) const& -> std::string{
 
     auto pref {cpp2::to_string(prefix)}; 
-    if ((*this) == past) {return pref + "past"; }
-    if ((*this) == future) {return cpp2::move(pref) + "future"; }
+    if ((*this) == janus::past) {return pref + "past"; }
+    if ((*this) == janus::future) {return cpp2::move(pref) + "future"; }
     return "invalid janus value"; 
     }
 
@@ -233,12 +233,12 @@ constexpr auto janus::operator=(janus&& that) noexcept -> janus& {
 [[nodiscard]] auto janus::from_string(cpp2::impl::in<std::string_view> s) -> janus{
 
     auto x {s}; 
-    if ("past" == x) {return past; }
-    else {if ("future" == cpp2::move(x)) {return future; }
+    if ("past" == x) {return janus::past; }
+    else {if ("future" == cpp2::move(x)) {return janus::future; }
 #line 1 "pure2-enum.cpp2"
 }
 CPP2_UFCS(report_violation)(cpp2::type_safety, CPP2_UFCS(c_str)(("can't convert string '" + cpp2::to_string(s) + "' to enum of type janus")));
-return past; 
+return janus::past; 
 }
 
 [[nodiscard]] auto janus::from_code(cpp2::impl::in<std::string_view> s) -> janus{
@@ -290,10 +290,10 @@ std::string sep {};
 if ((*this) == none) {return "(none)"; }
 
 auto pref {cpp2::to_string(prefix)}; 
-if (((*this) & cached) == cached) {ret += sep + pref + "cached";sep = separator;}
-if (((*this) & current) == current) {ret += sep + pref + "current";sep = separator;}
-if (((*this) & obsolete) == obsolete) {ret += sep + pref + "obsolete";sep = separator;}
-if (((*this) & cached_and_current) == cached_and_current) {ret += sep + cpp2::move(pref) + "cached_and_current";sep = separator;}
+if (((*this) & file_attributes::cached) == file_attributes::cached) {ret += sep + pref + "cached";sep = separator;}
+if (((*this) & file_attributes::current) == file_attributes::current) {ret += sep + pref + "current";sep = separator;}
+if (((*this) & file_attributes::obsolete) == file_attributes::obsolete) {ret += sep + pref + "obsolete";sep = separator;}
+if (((*this) & file_attributes::cached_and_current) == file_attributes::cached_and_current) {ret += sep + cpp2::move(pref) + "cached_and_current";sep = separator;}
 return cpp2::move(ret) + ")"; 
 }
 
@@ -304,11 +304,11 @@ return cpp2::move(ret) + ")";
 auto ret {none}; 
 do {{
 for ( auto const& x : cpp2::string_util::split_string_list(s) ) {
-if ("cached" == x) {ret |= cached;}
-else {if ("current" == x) {ret |= current;}
-else {if ("obsolete" == x) {ret |= obsolete;}
-else {if ("cached_and_current" == x) {ret |= cached_and_current;}
-else {if ("none" == x) {ret |= none;}
+if ("cached" == x) {ret |= file_attributes::cached;}
+else {if ("current" == x) {ret |= file_attributes::current;}
+else {if ("obsolete" == x) {ret |= file_attributes::obsolete;}
+else {if ("cached_and_current" == x) {ret |= file_attributes::cached_and_current;}
+else {if ("none" == x) {ret |= file_attributes::none;}
 else {goto BREAK_outer;}
 #line 1 "pure2-enum.cpp2"
 }}}}
@@ -320,7 +320,7 @@ return ret;
 false
 );
 CPP2_UFCS(report_violation)(cpp2::type_safety, CPP2_UFCS(c_str)(("can't convert string '" + cpp2::to_string(s) + "' to flag_enum of type file_attributes")));
-return none; 
+return file_attributes::none; 
 }
 
 [[nodiscard]] auto file_attributes::from_code(cpp2::impl::in<std::string_view> s) -> file_attributes{

regression-tests/test-results/version

@@ -1,4 +1,4 @@
 
-cppfront compiler v0.8.2 Build A207:1527
+cppfront compiler v0.8.2 Build A228:1826
 SPDX-License-Identifier  Apache-2.0 WITH LLVM-exception
 Copyright (c) 2022-2024  Herb Sutter

source/build.info

@@ -1 +1 @@
-"A207:1527"
+"A228:1826"

source/reflect.h

@@ -3585,13 +3585,13 @@ std::string to_string_impl{"    to_string_impl: (this, prefix: std::string_view"
             if (e.name != "_") {// ignore unnamed values
                 if (bitwise) {
                     if (e.name != "none") {
-                        to_string_impl += "    if (this & " + cpp2::to_string(e.name) + ") == " + cpp2::to_string(e.name) + " { "
+                        to_string_impl += "    if (this & " + cpp2::to_string(CPP2_UFCS(name)(t)) + "::" + cpp2::to_string(e.name) + ") == " + cpp2::to_string(CPP2_UFCS(name)(t)) + "::" + cpp2::to_string(e.name) + " { "
                                                   "ret += sep + pref + \"" + cpp2::to_string(e.name) + "\"; sep = separator; "
                                               "}\n";
                     }
                 }
                 else {
-                    to_string_impl += "    if this == " + cpp2::to_string(e.name) + " { return pref + \"" + cpp2::to_string(e.name) + "\"; }\n";
+                    to_string_impl += "    if this == " + cpp2::to_string(CPP2_UFCS(name)(t)) + "::" + cpp2::to_string(e.name) + " { return pref + \"" + cpp2::to_string(e.name) + "\"; }\n";
                 }
             }
         }
@@ -3646,7 +3646,7 @@ std::string_view else_{""};
 #line 1632 "reflect.h2"
         for ( 
               auto const& e : cpp2::move(enumerators) ) {
-            from_string += "            " + cpp2::to_string(else_) + "if \"" + cpp2::to_string(e.name) + "\" == x { " + cpp2::to_string(combine_op) + " " + cpp2::to_string(e.name) + "; }\n";
+            from_string += "            " + cpp2::to_string(else_) + "if \"" + cpp2::to_string(e.name) + "\" == x { " + cpp2::to_string(combine_op) + " " + cpp2::to_string(CPP2_UFCS(name)(t)) + "::" + cpp2::to_string(e.name) + "; }\n";
             else_ = "else ";
         }
 }
@@ -3660,7 +3660,7 @@ std::string_view else_{""};
         }
 
         from_string += "        cpp2::type_safety.report_violation( (\"can't convert string '\" + cpp2::to_string(s) + \"' to " + cpp2::to_string(cpp2::move(prefix)) + "enum of type " + cpp2::to_string(CPP2_UFCS(name)(t)) + "\").c_str() );\n"
-                       "        return " + cpp2::to_string(cpp2::move(default_value)) + ";\n"
+                       "        return " + cpp2::to_string(CPP2_UFCS(name)(t)) + "::" + cpp2::to_string(cpp2::move(default_value)) + ";\n"
                        "    }\n\n";
 
         CPP2_UFCS(add_member)(t, cpp2::move(from_string));
@@ -4362,12 +4362,12 @@ std::string sep {};
 if ((*this) == none) {return "(none)"; }
 
 auto pref {cpp2::to_string(prefix)}; 
-if (((*this) & case_insensitive) == case_insensitive) {ret += sep + pref + "case_insensitive";sep = separator;}
-if (((*this) & multiple_lines) == multiple_lines) {ret += sep + pref + "multiple_lines";sep = separator;}
-if (((*this) & single_line) == single_line) {ret += sep + pref + "single_line";sep = separator;}
-if (((*this) & no_group_captures) == no_group_captures) {ret += sep + pref + "no_group_captures";sep = separator;}
-if (((*this) & perl_code_syntax) == perl_code_syntax) {ret += sep + pref + "perl_code_syntax";sep = separator;}
-if (((*this) & perl_code_syntax_in_classes) == perl_code_syntax_in_classes) {ret += sep + cpp2::move(pref) + "perl_code_syntax_in_classes";sep = separator;}
+if (((*this) & expression_flags::case_insensitive) == expression_flags::case_insensitive) {ret += sep + pref + "case_insensitive";sep = separator;}
+if (((*this) & expression_flags::multiple_lines) == expression_flags::multiple_lines) {ret += sep + pref + "multiple_lines";sep = separator;}
+if (((*this) & expression_flags::single_line) == expression_flags::single_line) {ret += sep + pref + "single_line";sep = separator;}
+if (((*this) & expression_flags::no_group_captures) == expression_flags::no_group_captures) {ret += sep + pref + "no_group_captures";sep = separator;}
+if (((*this) & expression_flags::perl_code_syntax) == expression_flags::perl_code_syntax) {ret += sep + pref + "perl_code_syntax";sep = separator;}
+if (((*this) & expression_flags::perl_code_syntax_in_classes) == expression_flags::perl_code_syntax_in_classes) {ret += sep + cpp2::move(pref) + "perl_code_syntax_in_classes";sep = separator;}
 return cpp2::move(ret) + ")"; 
 }
 
@@ -4378,13 +4378,13 @@ return cpp2::move(ret) + ")";
 auto ret {none}; 
 do {{
 for ( auto const& x : cpp2::string_util::split_string_list(s) ) {
-if ("case_insensitive" == x) {ret |= case_insensitive;}
-else {if ("multiple_lines" == x) {ret |= multiple_lines;}
-else {if ("single_line" == x) {ret |= single_line;}
-else {if ("no_group_captures" == x) {ret |= no_group_captures;}
-else {if ("perl_code_syntax" == x) {ret |= perl_code_syntax;}
-else {if ("perl_code_syntax_in_classes" == x) {ret |= perl_code_syntax_in_classes;}
-else {if ("none" == x) {ret |= none;}
+if ("case_insensitive" == x) {ret |= expression_flags::case_insensitive;}
+else {if ("multiple_lines" == x) {ret |= expression_flags::multiple_lines;}
+else {if ("single_line" == x) {ret |= expression_flags::single_line;}
+else {if ("no_group_captures" == x) {ret |= expression_flags::no_group_captures;}
+else {if ("perl_code_syntax" == x) {ret |= expression_flags::perl_code_syntax;}
+else {if ("perl_code_syntax_in_classes" == x) {ret |= expression_flags::perl_code_syntax_in_classes;}
+else {if ("none" == x) {ret |= expression_flags::none;}
 else {goto BREAK_outer;}
 #line 1 "reflect.h2"
 }}}}}}

source/reflect.h2

@@ -1577,13 +1577,13 @@ basic_enum: (
             if e.name != "_" {  // ignore unnamed values
                 if bitwise {
                     if e.name != "none" {
-                        to_string_impl += "    if (this & (e.name)$) == (e.name)$ { "
+                        to_string_impl += "    if (this & (t.name())$::(e.name)$) == (t.name())$::(e.name)$ { "
                                                   "ret += sep + pref + \"(e.name)$\"; sep = separator; "
                                               "}\n";
                     }
                 }
                 else {
-                    to_string_impl += "    if this == (e.name)$ { return pref + \"(e.name)$\"; }\n";
+                    to_string_impl += "    if this == (t.name())$::(e.name)$ { return pref + \"(e.name)$\"; }\n";
                 }
             }
         }
@@ -1631,7 +1631,7 @@ basic_enum: (
         (copy else_: std::string_view = "")
         for  enumerators
         do   (e) {
-            from_string += "            (else_)$if \"(e.name)$\" == x { (combine_op)$ (e.name)$; }\n";
+            from_string += "            (else_)$if \"(e.name)$\" == x { (combine_op)$ (t.name())$::(e.name)$; }\n";
             else_ = "else ";
         }
 
@@ -1643,7 +1643,7 @@ basic_enum: (
         }
 
         from_string += "        cpp2::type_safety.report_violation( (\"can't convert string '\" + cpp2::to_string(s) + \"' to (prefix)$enum of type (t.name())$\").c_str() );\n"
-                       "        return (default_value)$;\n"
+                       "        return (t.name())$::(default_value)$;\n"
                        "    }\n\n";
 
         t.add_member( from_string );

source/to_cpp1.h

@@ -4429,34 +4429,6 @@ class cppfront
     }
 
 
-    //-----------------------------------------------------------------------
-    //  Within a type scope implementation, disallow declaring a name that
-    //  is the same as (i.e., shadows) a type scope name... this is a
-    //  convenient place to check because we have the decls stack
-    //
-    auto check_shadowing_of_type_scope_names(
-        declaration_node const& decl
-    )
-        -> bool
-    {
-        if (
-            decl.has_name()                 // this is a named declaration
-            && !decl.has_name("this")       // that's not 'this'
-            && !decl.parent_is_type()       // and the type isn't the direct parent
-            && is_name_declared_in_current_type_scope(*decl.name())
-            )                               // and it shadows a name
-        {
-            errors.emplace_back(
-                decl.position(),
-                "a type's implementation may not declare a name that is the same as (i.e., shadows) a type scope name - for example, a type scope function's local variable may not have the same as one of the type's members"
-            );
-            return false;
-        }
-
-        return true;
-    }
-
-
     //-----------------------------------------------------------------------
     //
     auto emit(
@@ -4475,10 +4447,6 @@ class cppfront
         assert( n.declaration );
         assert( !n.declaration->is_function() );
 
-        if (!check_shadowing_of_type_scope_names(*n.declaration)) {
-            return;
-        }
-
         assert( n.declaration->identifier );
         auto identifier     = print_to_string( *n.declaration->identifier );
         auto identifier_pos = n.position();
@@ -6032,10 +6000,6 @@ class cppfront
             ;
         auto is_in_type = n.parent_is_type();
 
-        if (!check_shadowing_of_type_scope_names(n)) {
-            return;
-        }
-
 
         //  If this is a function that has multiple return values,
         //  first we need to emit the struct that contains the returns