[clang-repl] Disambiguate declarations with private typedefs

[Hahnfeld]

Summary

Member functions and static variable definitions may use typedefs that
are private in the global context, but fine in the class context.

[v.g.vassilev]

clang/lib/Parse/ParseTentative.cpp

94

I am wondering what is the false positive rate of this change? That is, if we enable incremental parsing by default (in a local build) and then run all tests which do not produce diagnostics.

clang/test/Interpreter/disambiguate-decl-stmt.cpp

74

Could we move the diagnostic-producing cases in a separate file?

[Hahnfeld]

clang/lib/Parse/ParseTentative.cpp

94

With this patch and enabling IncrementalExtensions by default, it's at least not worse than current main: For all of check-clang, I see a number of failing unit tests that start hoarding some memory and are killed with std::bad_alloc or are stuck using 100% CPU. Those we probably want to debug independently of this change...

clang/test/Interpreter/disambiguate-decl-stmt.cpp

74

We could, but I'm actually not a big fan because it moves the expected failing test away from the related disambiguation tests above...

[v.g.vassilev]

This change looks reasonable to me.

clang/test/Interpreter/disambiguate-decl-stmt.cpp

74

Okay, fair enough.

clang/lib/Parse/ParseTentative.cpp

if (DisambiguatingWithExpression) {
         bool isDeductionGuide = Actions.isDeductionGuideName(
             getCurScope(), *II, Tok.getLocation(), SS, /*Template=*/nullptr);
         if (Actions.isCurrentClassName(*II, getCurScope(), &SS) ||
             isDeductionGuide) {
           if (isConstructorDeclarator(/*Unqualified=*/SS.isEmpty(),
                                       isDeductionGuide,
                                       DeclSpec::FriendSpecified::No))
             return true;
+        } else if (SS.isNotEmpty()) {
+          // If the scope is not empty, it could alternatively be something like
+          // a typedef or using declaration. That declaration might be private
+          // in the global context, which would be diagnosed by calling into
+          // isCXXSimpleDeclaration, but may actually be fine in the context of
+          // member functions and static variable definitions. Check if the next
+          // token is also an identifier and assume a declaration.
+          // We cannot check if the scopes match because the declarations could
+          // involve namespaces and friend declarations.
+          if (NextToken().is(tok::identifier))
+            return true;
         }
         break;
       }
       case tok::kw_operator:
         return true;
       case tok::tilde:
         return true;
       default:

clang/test/Interpreter/disambiguate-decl-stmt.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -fincremental-extensions -std=c++20 %s
 // RUN: %clang_cc1 -fsyntax-only -DMS -fms-extensions -verify -fincremental-extensions -std=c++20 %s
 
-// expected-no-diagnostics
-
 extern "C" int printf(const char*,...);
 
 // Decls which are hard to disambiguate
 
 // Templates
 namespace ns1 { template<typename T> void tmplt(T &) {}}
 int arg_tmplt = 12; ns1::tmplt(arg_tmplt);
 

 Dtor1::~Dtor1() { printf("Dtor1\n"); }
 Dtor1 d1;
 
 struct ANestedDtor { struct A1 { struct A2 { ~A2(); }; }; };
 ANestedDtor::A1::A2::~A2() { printf("Dtor A::A1::A2::~A2\n"); }
 
 // Ctors
 
+// Private typedefs / using declarations
+class PrivateUsingMember { using T = int; T f(); };
+PrivateUsingMember::T PrivateUsingMember::f() { return 0; }
+
+class PrivateUsingVar { using T = int; static T i; };
+PrivateUsingVar::T PrivateUsingVar::i = 42;
+
+// The same with namespaces
+namespace PrivateUsingNamespace { class Member { using T = int; T f(); }; }
+PrivateUsingNamespace::Member::T PrivateUsingNamespace::Member::f() { return 0; }
+
+namespace PrivateUsingNamespace { class Var { using T = int; static T i; }; }
+PrivateUsingNamespace::Var::T PrivateUsingNamespace::Var::i = 42;
+
+// The same with friend declarations
+class PrivateUsingFriendMember;
+class PrivateUsingFriendVar;
+class PrivateUsingFriend { friend class PrivateUsingFriendMember; friend class PrivateUsingFriendVar; using T = int; };
+class PrivateUsingFriendMember { PrivateUsingFriend::T f(); };
+PrivateUsingFriend::T PrivateUsingFriendMember::f() { return 0; }
+
+class PrivateUsingFriendVar { static PrivateUsingFriend::T i; };
+PrivateUsingFriend::T PrivateUsingFriendVar::i = 42;
+
+// The following should still diagnose (inspired by PR13642)
+// FIXME: Should not be diagnosed twice!
+class PR13642 { class Inner { public: static int i; }; };
+// expected-note@-1 2 {{implicitly declared private here}}
+PR13642::Inner::i = 5;
+// expected-error@-1 2 {{'Inner' is a private member of 'PR13642'}}
+
 // Deduction guide
 template<typename T> struct A { A(); A(T); };
 A() -> A<int>;
 
 struct S2 { S2(); };
 S2::S2() = default;
 
 namespace N { struct S { S(); }; }