Implementation of core DR580 and C++11 member access rules

[ismailp]

Summary

This patch implements resolution in core DR580, which is included in the C++11 standard. I have also changed variable names to match with LLVM style.

[silvas]

lib/Sema/SemaAccess.cpp

1487

While you're fixing style, you can probably bump the DC = FN statement onto the next line, as is more common.

[ismailp]

As a part of style changes, DC = FN moved to next line.

[rsmith]

lib/Sema/SemaAccess.cpp

1490

This should either be cast<DeclContext> or should not assign to DC if the templated decl is not a DeclContext (that is, if it's an alias template). I think we shouldn't get here for alias templates, so the cast<> is probably the right option; please add some testcases for that.

[ismailp]

I have added a few test cases for alias templates, a function template - to ensure I didn't break it - and extended previous one slightly. I initially had a FIXME for alias templates, but removed it right before I submitted the patch. I can't find a way to access a private variable/field from an alias template context.

[ismailp]

Committed in r180707.

lib/Sema/SemaAccess.cpp

 void Sema::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *D) {
   // Access control for names used in the declarations of functions
   // and function templates should normally be evaluated in the context
   // of the declaration, just in case it's a friend of something.
   // However, this does not apply to local extern declarations.
 
   DeclContext *DC = D->getDeclContext();
   if (FunctionDecl *FN = dyn_cast<FunctionDecl>(D)) {
     if (!DC->isFunctionOrMethod())
       DC = FN;
   } else if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) {
-    DC = dyn_cast<DeclContext>(TD->getTemplatedDecl());
+    DC = cast<DeclContext>(TD->getTemplatedDecl());
   }
 
   EffectiveContext EC(DC);
 
   AccessTarget Target(DD.getAccessData());
 
   if (CheckEffectiveAccess(*this, EC, DD.Loc, Target) == ::AR_inaccessible)
     DD.Triggered = true;

test/SemaCXX/access.cpp

namespace test1 {
   public:
     class X; // expected-error {{'X' redeclared with 'public' access}}
     class X {};
   };
 }
 
 // PR15209
 namespace PR15209 {
+  namespace alias_templates {
+    template<typename T1, typename T2> struct U { };
+    template<typename T1> using W = U<T1, float>;
+
+    class A {
+      typedef int I;
+      static constexpr I x = 0; // expected-note {{implicitly declared private here}}
+      static constexpr I y = 42; // expected-note {{implicitly declared private here}}
+      friend W<int>;
+    };
+
+    template<typename T1>
+    struct U<T1, float>  {
+      int v_;
+      // the following will trigger for U<float, float> instantiation, via W<float>
+      U() : v_(A::x) { } // expected-error {{'x' is a private member of 'PR15209::alias_templates::A'}}
+    };
+
+    template<typename T1>
+    struct U<T1, int> {
+      int v_;
+      U() : v_(A::y) { } // expected-error {{'y' is a private member of 'PR15209::alias_templates::A'}}
+    };
+
+    template struct U<int, int>; // expected-note {{in instantiation of member function 'PR15209::alias_templates::U<int, int>::U' requested here}}
+
+    void f()
+    {
+      W<int>();
+      // we should issue diagnostics for the following
+      W<float>(); // expected-note {{in instantiation of member function 'PR15209::alias_templates::U<float, float>::U' requested here}}
+    }
+  }
+
+  namespace templates {
     class A {
       typedef int I;  // expected-note {{implicitly declared private here}}
+      static constexpr I x = 0; // expected-note {{implicitly declared private here}}
+
       template<int> friend struct B;
       template<int> struct C;
-    template<int, typename T> friend struct E;
       template<template<int> class T> friend struct TT;
-    static constexpr int x = 0;
+      template<typename T> friend void funct(T);
     };
     template<A::I> struct B { };
 
     template<A::I> struct A::C { };
 
-  template<A::I> struct D { };  // expected-error {{'I' is a private member of 'PR15209::A'}}
-
-  template<A::I, typename T> struct E { };
-
     template<template<A::I> class T> struct TT {
-    T<A::I(0)> t;
+      T<A::x> t;
     };
+
     template struct TT<B>;
+    template<A::I> struct D { };  // expected-error {{'I' is a private member of 'PR15209::templates::A'}}
+    template struct TT<D>;
+
+    // function template case
+    template<typename T>
+    void funct(T)
+    {
+      (void)A::x;
+    }
+
+    template void funct<int>(int);
+
+    void f()
+    {
+      (void)A::x;  // expected-error {{'x' is a private member of 'PR15209::templates::A'}}
+    }
+  }
 }