PR13236 - Microsoft compatibility: support __super specifier to access members of base classes

[nikola]

Summary

This is a re-based version of Martin's patch from the bug report with few minor changes by me.

I don't think that we have to implement this feature identically to msvc, but I'm not opposed to it. I'd like to implement it in such a way that allows us to compile MFC code that depends on it. With that said here are some open questions.

• MSDN says that __super can't be used with using declarations but current patch doesn't emit a diagnostic in this case. I'd say that we don't have to because since msvc doesn't allow this there's no code written that does it.
• MSDN says that all accessible base class methods are considered during overload resolution with best one being selected. This is different from normal C++ rules where ordinary name lookup results in ambiguity. Current patch doesn't implement this logic (second test case fails) but similarly to my previous observation we might not need it as MFC doesn't use multiple inheritance. Client's might run into this issue in their classes, but in that case they can fix the code and move away from this extension.

What are your thoughts on this?

[rnk]

lib/AST/ItaniumMangle.cpp

804–806

This seems bad. IMO we can mangle this as a source name of super. It's in the implementer's namespace, so we should be OK. Please add a test for this. I think if you instantiate a template with a non-type template parameter using super you'll get this mangling.

lib/AST/NestedNameSpecifier.cpp

190–191

That seems wrong. It's dependent if there are dependent bases. Consider:

template <typename T>
struct A : T {
  __super::TypeFromBase x;
};

Maybe a __super specifier should store the RecordType that it will search inside of so that we can ask it this kind of question?

lib/Parse/ParseExprCXX.cpp

230

Please fix.

lib/Sema/SemaCXXScopeSpec.cpp

153

It might make more sense to treat this more like a TypeSpec NNS, and to return a stored tag decl here.

lib/Sema/SemaExpr.cpp

1953–1955

I'm not sure what should happen here...

lib/Sema/TreeTransform.h

3067–3068

If we go the route of storing the tag decl of the class that __super was used in, we will end up wanting to transform that decl from a pattern to a specialization.

test/SemaCXX/MicrosoftExtensions.cpp

444

Missing semicolon and closing brace for namespace?

This could also use a lot more tests.

[nikola]

Thanks for the input guys, I have two questions:

1. MSDN states "__super can only appear within the body of a member function." and yet msvc accepts it in a number of places (data member declaration, typedef, etc.). Do we wan't to be bug for bug compatible with msvc as I see that as major pain?

2. I agree with Aaron that we should support the 'name found in multiple bases' scenario. In theory this is simple enough, but I don't know how hard it is to implement in practice. I guess this is a question for Richard, can I get ambiguous declarations from LookupResult (I see that this is possible) and do an overload resolution on them (this looks more difficult as I don't know how to access the call arguments)?

[nikola]

I've gone full circle on this, Richard suggested resolving 'super' right away. I consumed tokens and annotated the trailing identifier as either type or primary expression. It was so simple and worked perfectly, until dependent bases showed up...

I started hacking and soon enough ended up with something that looks very much like the original patch with few minor changes. NNS now stores the CXXRecordDecl of the class 'super' appeared in, this is replaced by appropriate instantiation in case of templates. This makes us handle the 'derive from template parameter' case just fine, unlike msvc, but I'm fine with it. I guess we could produce an error like them if we wanted but I don't see the point.

I played with printfs to check if the right overload was selected but having tests would be nice. Do I emit IR, dump ast, or to something else?

[nikola]

This patch addresses issues raised by Aaron.

I don't think this could break ObjC, __super is treated as keyword unlike super from ObjC.

[nikola]

Modified tests to cover two issues I found when I ran the patch over our code base at work.

Gentle ping.

[rnk]

include/clang/AST/DataRecursiveASTVisitor.h

628

I would drop the "Ms" prefix, and just have a NestedNameSpecifier::Super enumerator. If gcc adds an incompatible super-like NNS we can cross that bridge when we get there.

include/clang/Sema/Sema.h

2611

"LookupInSuper"

4493

"ActOnSuperSpecifier"

lib/AST/ASTContext.cpp

4199

The super specifier isn't unique. I think we can canonicalize them similarly to how namespace specifiers are canonicalized: get the original CXXRecordDecl.

Unfortunately, I'm not sure how to test this.

lib/AST/ItaniumMangle.cpp

1462

This should be an assertion. We can't mangle __super, it is dependent.

lib/Sema/SemaCXXScopeSpec.cpp

256–259

I wonder if there is a better way to find the enclosing class scope. What about this test case:

struct B { typedef int T; };
struct A : B { enum C { X = sizeof(__super::T) }; };

test/SemaCXX/MicrosoftExtensions.cpp

404

"with a using declaration" :)

512

Can you add some tests with more nested DeclContexts? enums form a DeclContext, so those are handy and can go inside records and functions.

You can also use inner classes like:

struct Base { typedef int T; };
struct Outer { struct Inner : Base { static const int x = sizeof(__super::T); }; };

I bet __super also misbehaves inside a lambda. I won't insist on actually handling this case in this patch, but we should at least have test coverage that shows we don't crash.

[nikola]

lib/Sema/SemaCXXScopeSpec.cpp

256–259

You're right, but instead of handling this case I'd like to turn the assert bellow into an error. That will handle the lambdas as well. What do you think? This seems like an abuse to me :)

test/SemaCXX/MicrosoftExtensions.cpp

512

This example works just fine, I'll add it to existing tests.

We're not crashing on lambdas but I'll add the tests. Currently we error out because lambda has no base classes but hopefully we can fix this by doing what I suggested in the previous comment.

msvc is so funny:

void foo() {
  []{ __super::bar(); };
}

will fail with: 'super' : this keyword can only be used within the body of class member

struct A {
  void foo() {
    []{ __super::bar(); };
  }
};

will fail with: illegal use of 'super': 'A' does not have any base classes

Adding a base class will change the error to: illegal use of 'super': 'A::foo::lambda_hash>' does not have any base classes

Have I missed any cases?

[rnk]

lib/Sema/SemaCXXScopeSpec.cpp

256–259

I think your Scope check will actually break on simple things like:

struct B { typedef int T; };
struct A : B { void f() { if (int x = 1) { return sizeof(__super::T); } } };

Scopes have a fairly close mapping to curly braces in the source level.

I think you can use something like:

CXXRecordDecl *RD = nullptr;
for (const Scope *S = getCurScope(); S; S = S->getParent()) {
  if (S->isFnScope()) {
    MD = dyn_cast<CXXMethodDecl>(S->getEntity());
    if (MD) RD = MD->getParent();
    break;
  } else if (S->isClassScope()) {
    RD = cast<CXXRecordDecl>(S->getEntity());
    break;
  }
}
if (!RD) error

test/SemaCXX/MicrosoftExtensions.cpp

512

Nope, sounds good.

[nikola]

Fingers crossed.

I'm not too happy with what I had to do with FileCheck to get the lambda test case working. This whole file expects c++11 to be disabled which prevents me from using -verify. I thought about moving this to MicrosoftCompatibility.cpp but that's misleading as super is controlled by -mfs-extensions. Separate file for super tests would be the way to solve all problems?

[rnk]

lgtm

Please commit, this looks pretty good. If you want to make any more substantial changes I'd rather see a new patch. Thanks for the feature!

In D4468#15, @nikola wrote:

Fingers crossed.

I'm not too happy with what I had to do with FileCheck to get the lambda test case working. This whole file expects c++11 to be disabled which prevents me from using -verify. I thought about moving this to MicrosoftCompatibility.cpp but that's misleading as super is controlled by -mfs-extensions. Separate file for super tests would be the way to solve all problems?

I don't see the FileCheck hacks in this patch. Did you add the file? That said, feel free to split the __super test cases out. MicrosoftExtensions.cpp dates back to a simpler time when there were fewer extensions. :)

lib/Sema/SemaCXXScopeSpec.cpp

259

Why can't we use this in static member functions? It appears to work with MSVC 2013, and MSDN just says "can only appear inside a member function". This prints B::f:

extern "C" void puts(const char *);
struct B {
  static void f() {
    puts("B::f");
  }
};
struct A : B {
  static void f() {
    __super::f();
  }
};
int main() {
  A::f();
}

269

I think we should give a custom diagnostic for lambdas. The diagnostic we issue currently will confuse users, because it will appear that they are using __super from a method, and we will say they aren't.

lib/Sema/TreeTransform.h

3106

Use Q.getBeginLoc() instead of no SLoc?

test/SemaCXX/MicrosoftExtensions.cpp

407–409

Ouch, this is bad error recovery. It'd be nice to figure out why we can recover from 'Undeclared::foo();' with less spew.

[nikola]

Done in r218484. Thanks for the review and all suggestions.

Last patch was not the final version, but something I uploaded by mistake. I've allowed use from static members, added lambda diagnostic and moved test to a separate file. The only thing left would be to improve error recovery, I'll check this when I get the time.

include/clang/AST/ASTContext.h

                                      ASTContext&> 
     SubstTemplateTemplateParmPacks;
   
   /// \brief The set of nested name specifiers.
   ///
   /// This set is managed by the NestedNameSpecifier class.
   mutable llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers;
   mutable NestedNameSpecifier *GlobalNestedNameSpecifier;
+  mutable NestedNameSpecifier *MsSuperNestedNameSpecifier;
   friend class NestedNameSpecifier;
 
   /// \brief A cache mapping from RecordDecls to ASTRecordLayouts.
   ///
   /// This is lazily created.  This is intentionally not serialized.
   mutable llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>
     ASTRecordLayouts;
   mutable llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*>

include/clang/AST/DataRecursiveASTVisitor.h

   if (NNS->getPrefix())
     TRY_TO(TraverseNestedNameSpecifier(NNS->getPrefix()));
 
   switch (NNS->getKind()) {
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
   case NestedNameSpecifier::Global:
+  case NestedNameSpecifier::MsSuper:
     return true;
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate:
     TRY_TO(TraverseType(QualType(NNS->getAsType(), 0)));
   }
 
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc(
     NestedNameSpecifierLoc NNS) {
   if (!NNS)
     return true;
 
   if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
     TRY_TO(TraverseNestedNameSpecifierLoc(Prefix));
 
   switch (NNS.getNestedNameSpecifier()->getKind()) {
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
   case NestedNameSpecifier::Global:
+  case NestedNameSpecifier::MsSuper:
     return true;
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate:
     TRY_TO(TraverseTypeLoc(NNS.getTypeLoc()));
     break;
   }
 

include/clang/AST/NestedNameSpecifier.h

   /// can be an identifier, a declaration, or a type.
   ///
   /// When the pointer is NULL, this specifier represents the global
   /// specifier '::'. Otherwise, the pointer is one of
   /// IdentifierInfo*, Namespace*, or Type*, depending on the kind of
   /// specifier as encoded within the prefix.
   void* Specifier;
 
+  static char MsSuperSpecifierId;
+
 public:
   /// \brief The kind of specifier that completes this nested name
   /// specifier.
   enum SpecifierKind {
     /// \brief An identifier, stored as an IdentifierInfo*.
     Identifier,
     /// \brief A namespace, stored as a NamespaceDecl*.
     Namespace,
     /// \brief A namespace alias, stored as a NamespaceAliasDecl*.
     NamespaceAlias,
     /// \brief A type, stored as a Type*.
     TypeSpec,
     /// \brief A type that was preceded by the 'template' keyword,
     /// stored as a Type*.
     TypeSpecWithTemplate,
     /// \brief The global specifier '::'. There is no stored value.
-    Global
+    Global,
+    /// \brief The Microsoft's '__super' keyword. There is no stored value.
+    MsSuper
   };
 
 private:
   /// \brief Builds the global specifier.
   NestedNameSpecifier()
     : Prefix(nullptr, StoredIdentifier), Specifier(nullptr) {}
 
   /// \brief Copy constructor used internally to clone nested name

   /// type.
   static NestedNameSpecifier *Create(const ASTContext &Context,
                                      IdentifierInfo *II);
 
   /// \brief Returns the nested name specifier representing the global
   /// scope.
   static NestedNameSpecifier *GlobalSpecifier(const ASTContext &Context);
 
+  /// \brief Returns the nested name specifier representing the __super keyword.
+  static NestedNameSpecifier *MsSuperSpecifier(const ASTContext &Context);
+
   /// \brief Return the prefix of this nested name specifier.
   ///
   /// The prefix contains all of the parts of the nested name
   /// specifier that preced this current specifier. For example, for a
   /// nested name specifier that represents "foo::bar::", the current
   /// specifier will contain "bar::" and the prefix will contain
   /// "foo::".
   NestedNameSpecifier *getPrefix() const { return Prefix.getPointer(); }

   /// \param ColonColonLoc The location of the trailing '::'.
   void Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
               SourceLocation AliasLoc, SourceLocation ColonColonLoc);
 
   /// \brief Turn this (empty) nested-name-specifier into the global
   /// nested-name-specifier '::'.
   void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc);
 
+  /// \brief Turn this (empty) nested-name-specifier into the Microsoft's
+  /// '__super' specifier.
+  void MakeMsSuper(ASTContext &Context, SourceLocation MsSuperLoc,
+                   SourceLocation ColonColonLoc);
+
   /// \brief Make a new nested-name-specifier from incomplete source-location
   /// information.
   ///
   /// This routine should be used very, very rarely, in cases where we
   /// need to synthesize a nested-name-specifier. Most code should instead use
   /// \c Adopt() with a proper \c NestedNameSpecifierLoc.
   void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier,
                    SourceRange R);

include/clang/AST/RecursiveASTVisitor.h

   if (NNS->getPrefix())
     TRY_TO(TraverseNestedNameSpecifier(NNS->getPrefix()));
 
   switch (NNS->getKind()) {
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
   case NestedNameSpecifier::Global:
+  case NestedNameSpecifier::MsSuper:
     return true;
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate:
     TRY_TO(TraverseType(QualType(NNS->getAsType(), 0)));
   }
 
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc(
     NestedNameSpecifierLoc NNS) {
   if (!NNS)
     return true;
 
   if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
     TRY_TO(TraverseNestedNameSpecifierLoc(Prefix));
 
   switch (NNS.getNestedNameSpecifier()->getKind()) {
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
   case NestedNameSpecifier::Global:
-    return true;
+  case NestedNameSpecifier::MsSuper:
+     return true;
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate:
     TRY_TO(TraverseTypeLoc(NNS.getTypeLoc()));
     break;
   }
 
   return true;

include/clang/Basic/TokenKinds.def

 // Microsoft Extension.
 KEYWORD(__declspec                  , KEYALL)
 KEYWORD(__cdecl                     , KEYALL)
 KEYWORD(__stdcall                   , KEYALL)
 KEYWORD(__fastcall                  , KEYALL)
 KEYWORD(__thiscall                  , KEYALL)
 KEYWORD(__forceinline               , KEYMS)
 KEYWORD(__unaligned                 , KEYMS)
+KEYWORD(__super                     , KEYMS)
 
 // OpenCL address space qualifiers
 KEYWORD(__global                    , KEYOPENCL)
 KEYWORD(__local                     , KEYOPENCL)
 KEYWORD(__constant                  , KEYOPENCL)
 KEYWORD(__private                   , KEYOPENCL)
 ALIAS("global", __global            , KEYOPENCL)
 ALIAS("local", __local              , KEYOPENCL)

include/clang/Sema/DeclSpec.h

   /// \param ColonColonLoc The location of the trailing '::'.
   void Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
               SourceLocation AliasLoc, SourceLocation ColonColonLoc);
 
   /// \brief Turn this (empty) nested-name-specifier into the global
   /// nested-name-specifier '::'.
   void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc);
   
+  /// \brief Turn this (empty) nested-name-specifier into the Microsoft's
+  /// '__super' specifier.
+  void MakeMsSuper(ASTContext &Context, SourceLocation MsSuperLoc,
+                   SourceLocation ColonColonLoc);
+
   /// \brief Make a new nested-name-specifier from incomplete source-location
   /// information.
   ///
   /// FIXME: This routine should be used very, very rarely, in cases where we
   /// need to synthesize a nested-name-specifier. Most code should instead use
   /// \c Adopt() with a proper \c NestedNameSpecifierLoc.
   void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, 
                    SourceRange R);

include/clang/Sema/Sema.h

                               SourceLocation Loc,
                               LookupNameKind NameKind,
                               RedeclarationKind Redecl
                                 = NotForRedeclaration);
   bool LookupName(LookupResult &R, Scope *S,
                   bool AllowBuiltinCreation = false);
   bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
                            bool InUnqualifiedLookup = false);
+  bool LookupInBaseClasses(LookupResult &R, CXXRecordDecl *LookupRec,
+                           bool InUnqualifiedLookup = false);
   bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
                         bool AllowBuiltinCreation = false,
                         bool EnteringContext = false);
   ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,
                                    RedeclarationKind Redecl
                                      = NotForRedeclaration);
 
   void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,

                                                unsigned Quals);
   CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,
                                          bool RValueThis, unsigned ThisQuals);
   CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,
                                               unsigned Quals);
   CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,
                                         bool RValueThis, unsigned ThisQuals);
   CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);
 
   bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id);
   LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R,
                                                     ArrayRef<QualType> ArgTys,
                                                     bool AllowRaw,
                                                     bool AllowTemplate,
                                                     bool AllowStringTemplate);
   bool isKnownName(StringRef name);
 

 
   ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
                                SourceLocation TemplateKWLoc,
                                UnqualifiedId &Id,
                                bool HasTrailingLParen, bool IsAddressOfOperand,
                                CorrectionCandidateCallback *CCC = nullptr,
                                bool IsInlineAsmIdentifier = false);
 
+  ExprResult ActOnMsSuperIdExpression(Scope *S, CXXScopeSpec &SS,
+                                      const DeclarationNameInfo &NameInfo);
+
   void DecomposeUnqualifiedId(const UnqualifiedId &Id,
                               TemplateArgumentListInfo &Buffer,
                               DeclarationNameInfo &NameInfo,
                               const TemplateArgumentListInfo *&TemplateArgs);
 
   bool
   DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
                       CorrectionCandidateCallback &CCC,

   ///
   /// \param SS The nested-name-specifier, which will be updated in-place
   /// to reflect the parsed nested-name-specifier.
   ///
   /// \returns true if an error occurred, false otherwise.
   bool ActOnCXXGlobalScopeSpecifier(Scope *S, SourceLocation CCLoc,
                                     CXXScopeSpec &SS);
 
+  bool ActOnCXXMsSuperScopeSpecifier(Scope *S, SourceLocation SuperLoc,
+                                     SourceLocation CCLoc, CXXScopeSpec &SS);
+
   bool isAcceptableNestedNameSpecifier(const NamedDecl *SD);
   NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
 
   bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
                                     SourceLocation IdLoc,
                                     IdentifierInfo &II,
                                     ParsedType ObjectType);
 

   /// \param CCLoc The location of the '::'.
   ///
   /// \param ObjectType The type of the object, if we're parsing
   /// nested-name-specifier in a member access expression.
   ///
   /// \param EnteringContext Whether we're entering the context nominated by
   /// this nested-name-specifier.
   ///
   /// \param SS The nested-name-specifier, which is both an input
   /// parameter (the nested-name-specifier before this type) and an
   /// output parameter (containing the full nested-name-specifier,
   /// including this new type).
   ///
   /// \param ErrorRecoveryLookup If true, then this method is called to improve
   /// error recovery. In this case do not emit error message.
   ///
   /// \param IsCorrectedToColon If not null, suggestions to replace '::' -> ':'
   /// are allowed.  The bool value pointed by this parameter is set to 'true'
   /// if the identifier is treated as if it was followed by ':', not '::'.
   ///
   /// \returns true if an error occurred, false otherwise.
   bool ActOnCXXNestedNameSpecifier(Scope *S,
                                    IdentifierInfo &Identifier,

lib/AST/ASTContext.cpp

 ASTContext::ASTContext(LangOptions& LOpts, SourceManager &SM,
                        IdentifierTable &idents, SelectorTable &sels,
                        Builtin::Context &builtins)
   : FunctionProtoTypes(this_()),
     TemplateSpecializationTypes(this_()),
     DependentTemplateSpecializationTypes(this_()),
     SubstTemplateTemplateParmPacks(this_()),
     GlobalNestedNameSpecifier(nullptr),
+    MsSuperNestedNameSpecifier(nullptr),
     Int128Decl(nullptr), UInt128Decl(nullptr), Float128StubDecl(nullptr),
     BuiltinVaListDecl(nullptr),
     ObjCIdDecl(nullptr), ObjCSelDecl(nullptr), ObjCClassDecl(nullptr),
     ObjCProtocolClassDecl(nullptr), BOOLDecl(nullptr),
     CFConstantStringTypeDecl(nullptr), ObjCInstanceTypeDecl(nullptr),
     FILEDecl(nullptr),
     jmp_bufDecl(nullptr), sigjmp_bufDecl(nullptr), ucontext_tDecl(nullptr),
     BlockDescriptorType(nullptr), BlockDescriptorExtendedType(nullptr),

     // Otherwise, just canonicalize the type, and force it to be a TypeSpec.
     // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the
     // first place?
     return NestedNameSpecifier::Create(*this, nullptr, false,
                                        const_cast<Type *>(T.getTypePtr()));
   }
 
   case NestedNameSpecifier::Global:
-    // The global specifier is canonical and unique.
+  case NestedNameSpecifier::MsSuper:
+    // Both the global and the __super specifier are canonical and unique.
     return NNS;
   }
 
   llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
 }
 
 
 const ArrayType *ASTContext::getAsArrayType(QualType T) const {
   // Handle the non-qualified case efficiently.
   if (!T.hasLocalQualifiers()) {
     // Handle the common positive case fast.
     if (const ArrayType *AT = dyn_cast<ArrayType>(T))

lib/AST/ASTImporter.cpp

           cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
       return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
     }
     return nullptr;
 
   case NestedNameSpecifier::Global:
     return NestedNameSpecifier::GlobalSpecifier(ToContext);
 
+  case NestedNameSpecifier::MsSuper:
+    return NestedNameSpecifier::MsSuperSpecifier(ToContext);
+
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate: {
       QualType T = Import(QualType(FromNNS->getAsType(), 0u));
       if (!T.isNull()) {
         bool bTemplate = FromNNS->getKind() == 
                          NestedNameSpecifier::TypeSpecWithTemplate;
         return NestedNameSpecifier::Create(ToContext, prefix, 
                                            bTemplate, T.getTypePtr());

lib/AST/ItaniumMangle.cpp

   // <unresolved-name> ::= srN <unresolved-type> <unresolved-qualifier-level>+ E
   //                       <base-unresolved-name>
 
   // A::x, N::y, A<T>::z; "gs" means leading "::"
   // <unresolved-name> ::= [gs] sr <unresolved-qualifier-level>+ E
   //                       <base-unresolved-name>
 
   switch (qualifier->getKind()) {
+  case NestedNameSpecifier::MsSuper:
+    // nothing
+    return;
   case NestedNameSpecifier::Global:
     Out << "gs";
 
     // We want an 'sr' unless this is the entire NNS.
     if (recursive)
       Out << "sr";
 
     // We never want an 'E' here.

   if (Number > 1)
     mangleNumber(Number - 2);
   Out << '_';  
 }
 
 void CXXNameMangler::manglePrefix(NestedNameSpecifier *qualifier) {
   switch (qualifier->getKind()) {
   case NestedNameSpecifier::Global:
+  case NestedNameSpecifier::MsSuper:
     // nothing
     return;
 
   case NestedNameSpecifier::Namespace:
     mangleName(qualifier->getAsNamespace());
     return;
 
   case NestedNameSpecifier::NamespaceAlias:

lib/AST/NestedNameSpecifier.cpp

 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 
 using namespace clang;
 
+char NestedNameSpecifier::MsSuperSpecifierId;
+
 NestedNameSpecifier *
 NestedNameSpecifier::FindOrInsert(const ASTContext &Context,
                                   const NestedNameSpecifier &Mockup) {
   llvm::FoldingSetNodeID ID;
   Mockup.Profile(ID);
 
   void *InsertPos = nullptr;
   NestedNameSpecifier *NNS

 NestedNameSpecifier::GlobalSpecifier(const ASTContext &Context) {
   if (!Context.GlobalNestedNameSpecifier)
     Context.GlobalNestedNameSpecifier =
         new (Context, llvm::alignOf<NestedNameSpecifier>())
             NestedNameSpecifier();
   return Context.GlobalNestedNameSpecifier;
 }
 
+NestedNameSpecifier *
+NestedNameSpecifier::MsSuperSpecifier(const ASTContext &Context) {
+  if (!Context.MsSuperNestedNameSpecifier) {
+    Context.MsSuperNestedNameSpecifier =
+        new (Context, llvm::alignOf<NestedNameSpecifier>())
+        NestedNameSpecifier();
+    Context.MsSuperNestedNameSpecifier->Specifier = &MsSuperSpecifierId;
+  }
+
+  return Context.MsSuperNestedNameSpecifier;
+}
+
 NestedNameSpecifier::SpecifierKind NestedNameSpecifier::getKind() const {
   if (!Specifier)
     return Global;
 
+  if (Specifier == &MsSuperSpecifierId)
+    return MsSuper;
+
   switch (Prefix.getInt()) {
   case StoredIdentifier:
     return Identifier;
 
   case StoredNamespaceOrAlias:
     return isa<NamespaceDecl>(static_cast<NamedDecl *>(Specifier))? Namespace
                                                             : NamespaceAlias;
 

   switch (getKind()) {
   case Identifier:
     // Identifier specifiers always represent dependent types
     return true;
 
   case Namespace:
   case NamespaceAlias:
   case Global:
+  case MsSuper:
     return false;
 
   case TypeSpec:
   case TypeSpecWithTemplate:
     return getAsType()->isDependentType();
   }
 
   llvm_unreachable("Invalid NNS Kind!");
 }
 
 /// \brief Whether this nested name specifier refers to a dependent
 /// type or not.
 bool NestedNameSpecifier::isInstantiationDependent() const {
   switch (getKind()) {
   case Identifier:
     // Identifier specifiers always represent dependent types
     return true;
     
   case Namespace:
   case NamespaceAlias:
   case Global:
+  case MsSuper:
     return false;
     
   case TypeSpec:
   case TypeSpecWithTemplate:
     return getAsType()->isInstantiationDependentType();
   }
 
   llvm_unreachable("Invalid NNS Kind!");
 }
 
 bool NestedNameSpecifier::containsUnexpandedParameterPack() const {
   switch (getKind()) {
   case Identifier:
     return getPrefix() && getPrefix()->containsUnexpandedParameterPack();
 
   case Namespace:
   case NamespaceAlias:
   case Global:
+  case MsSuper:
     return false;
 
   case TypeSpec:
   case TypeSpecWithTemplate:
     return getAsType()->containsUnexpandedParameterPack();
   }
 
   llvm_unreachable("Invalid NNS Kind!");

 
   case NamespaceAlias:
     OS << getAsNamespaceAlias()->getName();
     break;
 
   case Global:
     break;
 
+  case MsSuper:
+    OS << "__super";
+    break;
+
   case TypeSpecWithTemplate:
     OS << "template ";
     // Fall through to print the type.
 
   case TypeSpec: {
     const Type *T = getAsType();
 
     PrintingPolicy InnerPolicy(Policy);

   switch (Qualifier->getKind()) {
   case NestedNameSpecifier::Global:
     // Nothing more to add.
     break;
 
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
+  case NestedNameSpecifier::MsSuper:
     // The location of the identifier or namespace name.
     Length += sizeof(unsigned);
     break;
 
   case NestedNameSpecifier::TypeSpecWithTemplate:
   case NestedNameSpecifier::TypeSpec:
     // The "void*" that points at the TypeLoc data.
     // Note: the 'template' keyword is part of the TypeLoc.

   unsigned Offset = getDataLength(Qualifier->getPrefix());
   switch (Qualifier->getKind()) {
   case NestedNameSpecifier::Global:
     return LoadSourceLocation(Data, Offset);
 
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
+  case NestedNameSpecifier::MsSuper:
     return SourceRange(LoadSourceLocation(Data, Offset),
                        LoadSourceLocation(Data, Offset + sizeof(unsigned)));
 
   case NestedNameSpecifier::TypeSpecWithTemplate:
   case NestedNameSpecifier::TypeSpec: {
     // The "void*" that points at the TypeLoc data.
     // Note: the 'template' keyword is part of the TypeLoc.
     void *TypeData = LoadPointer(Data, Offset);

                                                SourceLocation ColonColonLoc) {
   assert(!Representation && "Already have a nested-name-specifier!?");
   Representation = NestedNameSpecifier::GlobalSpecifier(Context);
   
   // Push source-location info into the buffer.
   SaveSourceLocation(ColonColonLoc, Buffer, BufferSize, BufferCapacity);
 }
 
+void NestedNameSpecifierLocBuilder::MakeMsSuper(ASTContext &Context,
+                                                SourceLocation MsSuperLoc,
+                                                SourceLocation ColonColonLoc) {
+  assert(!Representation && "Already have a nested-name-specifier!?");
+  Representation = NestedNameSpecifier::MsSuperSpecifier(Context);
+
+  // Push source-location info into the buffer.
+  SaveSourceLocation(MsSuperLoc, Buffer, BufferSize, BufferCapacity);
+  SaveSourceLocation(ColonColonLoc, Buffer, BufferSize, BufferCapacity);
+}
+
 void NestedNameSpecifierLocBuilder::MakeTrivial(ASTContext &Context, 
                                                 NestedNameSpecifier *Qualifier, 
                                                 SourceRange R) {
   Representation = Qualifier;
   
   // Construct bogus (but well-formed) source information for the 
   // nested-name-specifier.
   BufferSize = 0;
   SmallVector<NestedNameSpecifier *, 4> Stack;
   for (NestedNameSpecifier *NNS = Qualifier; NNS; NNS = NNS->getPrefix())
     Stack.push_back(NNS);
   while (!Stack.empty()) {
     NestedNameSpecifier *NNS = Stack.pop_back_val();
     switch (NNS->getKind()) {
       case NestedNameSpecifier::Identifier:
       case NestedNameSpecifier::Namespace:
       case NestedNameSpecifier::NamespaceAlias:
+      case NestedNameSpecifier::MsSuper:
         SaveSourceLocation(R.getBegin(), Buffer, BufferSize, BufferCapacity);
         break;
         
       case NestedNameSpecifier::TypeSpec:
       case NestedNameSpecifier::TypeSpecWithTemplate: {
         TypeSourceInfo *TSInfo
         = Context.getTrivialTypeSourceInfo(QualType(NNS->getAsType(), 0),
                                            R.getBegin());

lib/Parse/ParseExpr.cpp

 
   case tok::kw_decltype:
     // Annotate the token and tail recurse.
     if (TryAnnotateTypeOrScopeToken())
       return ExprError();
     assert(Tok.isNot(tok::kw_decltype));
     return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
       
+  case tok::kw___super:
   case tok::identifier: {      // primary-expression: identifier
                                // unqualified-id: identifier
                                // constant: enumeration-constant
     // Turn a potentially qualified name into a annot_typename or
     // annot_cxxscope if it would be valid.  This handles things like x::y, etc.
     if (getLangOpts().CPlusPlus) {
       // Avoid the unnecessary parse-time lookup in the common case
       // where the syntax forbids a type.

lib/Parse/ParseExprCXX.cpp

 
     // '::' - Global scope qualifier.
     if (Actions.ActOnCXXGlobalScopeSpecifier(getCurScope(), ConsumeToken(), SS))
       return true;
 
     CheckForLParenAfterColonColon();
 
     HasScopeSpecifier = true;
+  } else if (Tok.is(tok::kw___super)) {
+    SourceLocation SuperLoc = ConsumeToken();
+    if (Tok.isNot(tok::coloncolon)) {
+      // XXX: Diagnose
+      return true;
+    }
+    if (Actions.ActOnCXXMsSuperScopeSpecifier(getCurScope(), SuperLoc,
+                                              ConsumeToken(), SS))
+      return true;
+    HasScopeSpecifier = true;
   }
 
   bool CheckForDestructor = false;
   if (MayBePseudoDestructor && *MayBePseudoDestructor) {
     CheckForDestructor = true;
     *MayBePseudoDestructor = false;
   }
 

lib/Parse/Parser.cpp

 ///
 /// This returns true if an error occurred.
 ///
 /// Note that this routine emits an error if you call it with ::new or ::delete
 /// as the current tokens, so only call it in contexts where these are invalid.
 bool Parser::TryAnnotateTypeOrScopeToken(bool EnteringContext, bool NeedType) {
   assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon)
           || Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope)
-          || Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id))
+          || Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id)
+          || Tok.is(tok::kw___super))
           && "Cannot be a type or scope token!");
 
   if (Tok.is(tok::kw_typename)) {
     // MSVC lets you do stuff like:
     //   typename typedef T_::D D;
     //
     // We will consume the typedef token here and put it back after we have
     // parsed the first identifier, transforming it into something more like:

lib/Sema/DeclSpec.cpp

   Builder.MakeGlobal(Context, ColonColonLoc);
   
   Range = SourceRange(ColonColonLoc);
   
   assert(Range == Builder.getSourceRange() &&
          "NestedNameSpecifierLoc range computation incorrect");
 }
 
+void CXXScopeSpec::MakeMsSuper(ASTContext &Context, SourceLocation MsSuperLoc,
+                               SourceLocation ColonColonLoc) {
+  Builder.MakeMsSuper(Context, MsSuperLoc, ColonColonLoc);
+
+  Range.setBegin(MsSuperLoc);
+  Range.setEnd(ColonColonLoc);
+
+  assert(Range == Builder.getSourceRange() &&
+         "NestedNameSpecifierLoc range computation incorrect");
+}
+
 void CXXScopeSpec::MakeTrivial(ASTContext &Context, 
                                NestedNameSpecifier *Qualifier, SourceRange R) {
   Builder.MakeTrivial(Context, Qualifier, R);
   Range = R;
 }
 
 void CXXScopeSpec::Adopt(NestedNameSpecifierLoc Other) {
   if (!Other) {

lib/Sema/SemaCXXScopeSpec.cpp

   case NestedNameSpecifier::TypeSpecWithTemplate: {
     const TagType *Tag = NNS->getAsType()->getAs<TagType>();
     assert(Tag && "Non-tag type in nested-name-specifier");
     return Tag->getDecl();
   }
 
   case NestedNameSpecifier::Global:
     return Context.getTranslationUnitDecl();
+
+  case NestedNameSpecifier::MsSuper:
+    return nullptr;
   }
 
   llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
 }
 
+bool Sema::ActOnCXXMsSuperScopeSpecifier(Scope *S, SourceLocation SuperLoc,
+                                         SourceLocation CCLoc,
+                                         CXXScopeSpec &SS) {
+  SS.MakeMsSuper(Context, SuperLoc, CCLoc);
+  return false;
+}
+
 bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) {
   if (!SS.isSet() || SS.isInvalid())
     return false;
 
   return SS.getScopeRep()->isDependent();
 }
 
 /// \brief If the given nested name specifier refers to the current

 
   // If we're currently defining this type, then lookup into the
   // type is okay: don't complain that it isn't complete yet.
   QualType type = Context.getTypeDeclType(tag);
   const TagType *tagType = type->getAs<TagType>();
   if (tagType && tagType->isBeingDefined())
     return false;
 
   SourceLocation loc = SS.getLastQualifierNameLoc();

   //   function's class. If it is not found, or if the name is part of
   //   a template-argument in a template-id, the look up is as
   //   described for unqualified names in the definition of the class
   //   granting friendship.
   // i.e. we don't push a scope unless it's a class member.
 
   switch (Qualifier->getKind()) {
   case NestedNameSpecifier::Global:
+  case NestedNameSpecifier::MsSuper:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
     // These are always namespace scopes.  We never want to enter a
     // namespace scope from anything but a file context.
     return CurContext->getRedeclContext()->isFileContext();
 
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::TypeSpec:

lib/Sema/SemaExpr.cpp

     return true;
   }
 
   // Give up, we can't recover.
   Diag(R.getNameLoc(), diagnostic) << Name;
   return true;
 }
 
+ExprResult Sema::ActOnMsSuperIdExpression(Scope *S, CXXScopeSpec &SS,
+                                          const DeclarationNameInfo &NameInfo) {
+  Scope *FnScope = S->getFnParent();
+  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnScope->getEntity());
+  CXXRecordDecl *Rec = Method->getParent();
+  LookupResult R(*this, NameInfo, LookupOrdinaryName);
+  if (LookupInBaseClasses(R, Rec)) {
+    // if (R.getAmbiguityKind() == LookupResult::AmbiguousBaseSubobjectTypes) {
+    // Do overload resolution?
+    // }
+
+    return BuildImplicitMemberExpr(SS, SourceLocation(), R, nullptr, true);
+  }
+
+  Diag(R.getNameLoc(), diag::err_no_member) << R.getLookupName() << Rec;
+  return ExprError();
+}
+
 /// In Microsoft mode, if we are inside a template class whose parent class has
 /// dependent base classes, and we can't resolve an unqualified identifier, then
 /// assume the identifier is a member of a dependent base class.  We can only
 /// recover successfully in static methods, instance methods, and other contexts
 /// where 'this' is available.  This doesn't precisely match MSVC's
 /// instantiation model, but it's close enough.
 static Expr *
 recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context,

 
   TemplateArgumentListInfo TemplateArgsBuffer;
 
   // Decompose the UnqualifiedId into the following data.
   DeclarationNameInfo NameInfo;
   const TemplateArgumentListInfo *TemplateArgs;
   DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs);
 
+  const NestedNameSpecifier *NNS = SS.getScopeRep();
+  if (NNS && NNS->getKind() == NestedNameSpecifier::MsSuper)
+    return ActOnMsSuperIdExpression(S, SS, NameInfo);
+
   DeclarationName Name = NameInfo.getName();
   IdentifierInfo *II = Name.getAsIdentifierInfo();
   SourceLocation NameLoc = NameInfo.getLoc();
 
   // C++ [temp.dep.expr]p3:
   //   An id-expression is type-dependent if it contains:
   //     -- an identifier that was declared with a dependent type,
   //        (note: handled after lookup)

   //   class Derived1 : public Base { };
   //   class Derived2 : public Base { };
   //   class VeryDerived : public Derived1, public Derived2 { void f(); };
   //
   //   void VeryDerived::f() {
   //     x = 17; // error: ambiguous base subobjects
   //     Derived1::x = 17; // okay, pick the Base subobject of Derived1
   //   }
-  if (Qualifier && Qualifier->getAsType()) {
+  if (Qualifier && Qualifier->getAsType() &&
+      Qualifier->getKind() != NestedNameSpecifier::MsSuper) {
     QualType QType = QualType(Qualifier->getAsType(), 0);
     assert(QType->isRecordType() && "lookup done with non-record type");
 
     QualType QRecordType = QualType(QType->getAs<RecordType>(), 0);
 
     // In C++98, the qualifier type doesn't actually have to be a base
     // type of the object type, in which case we just ignore it.
     // Otherwise build the appropriate casts.

lib/Sema/SemaExprCXX.cpp

     assert(NNS->getAsIdentifier() == &Name && "not a constructor name");
     Type = Context.getDependentNameType(ETK_None, NNS->getPrefix(),
                                         NNS->getAsIdentifier());
     break;
 
   case NestedNameSpecifier::Global:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
+  case NestedNameSpecifier::MsSuper:
     llvm_unreachable("Nested name specifier is not a type for inheriting ctor");
   }
 
   // This reference to the type is located entirely at the location of the
   // final identifier in the qualified-id.
   return CreateParsedType(Type,
                           Context.getTrivialTypeSourceInfo(Type, NameLoc));
 }

     // case where the scope is dependent.
     Diag(Name.getLocStart(), diag::err_literal_operator_id_outside_namespace)
       << SS.getScopeRep();
     return true;
 
   case NestedNameSpecifier::Global:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
+  case NestedNameSpecifier::MsSuper:
     return false;
   }
 
   llvm_unreachable("unknown nested name specifier kind");
 }
 
 /// \brief Build a C++ typeid expression with a type operand.
 ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,

lib/Sema/SemaLookup.cpp

     return LookupQualifiedNameInUsingDirectives(*this, R, LookupCtx);
 
   // If this isn't a C++ class, we aren't allowed to look into base
   // classes, we're done.
   CXXRecordDecl *LookupRec = dyn_cast<CXXRecordDecl>(LookupCtx);
   if (!LookupRec || !LookupRec->getDefinition())
     return false;
 
+  return LookupInBaseClasses(R, LookupRec, InUnqualifiedLookup);
+}
+
+bool Sema::LookupInBaseClasses(LookupResult &R, CXXRecordDecl *LookupRec,
+                               bool InUnqualifiedLookup) {
   // If we're performing qualified name lookup into a dependent class,
   // then we are actually looking into a current instantiation. If we have any
   // dependent base classes, then we either have to delay lookup until
   // template instantiation time (at which point all bases will be available)
   // or we have to fail.
   if (!InUnqualifiedLookup && LookupRec->isDependentContext() &&
       LookupRec->hasAnyDependentBases()) {
     R.setNotFoundInCurrentInstantiation();

     break;
 
   case NestedNameSpecifier::TypeSpecWithTemplate:
   case NestedNameSpecifier::TypeSpec:
     II = QualType(NNS->getAsType(), 0).getBaseTypeIdentifier();
     break;
 
   case NestedNameSpecifier::Global:
+  case NestedNameSpecifier::MsSuper:
     return;
   }
 
   if (II)
     Identifiers.push_back(II);
 }
 
 namespace {

lib/Sema/SemaTemplate.cpp

   if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
     return true;
 
   switch (NNS->getKind()) {
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
   case NestedNameSpecifier::Global:
+  case NestedNameSpecifier::MsSuper:
     return false;
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate:
     return Visit(QualType(NNS->getAsType(), 0));
   }
   llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
 }

lib/Sema/SemaType.cpp

         case NestedNameSpecifier::Identifier:
           ClsType = Context.getDependentNameType(ETK_None, NNSPrefix,
                                                  NNS->getAsIdentifier());
           break;
 
         case NestedNameSpecifier::Namespace:
         case NestedNameSpecifier::NamespaceAlias:
         case NestedNameSpecifier::Global:
+        case NestedNameSpecifier::MsSuper:
           llvm_unreachable("Nested-name-specifier must name a type");
 
         case NestedNameSpecifier::TypeSpec:
         case NestedNameSpecifier::TypeSpecWithTemplate:
           ClsType = QualType(NNS->getAsType(), 0);
           // Note: if the NNS has a prefix and ClsType is a nondependent
           // TemplateSpecializationType, then the NNS prefix is NOT included
           // in ClsType; hence we wrap ClsType into an ElaboratedType.

         } else {
           ClsTL.initializeFullCopy(NNSLoc.getTypeLoc());
         }
         break;
 
       case NestedNameSpecifier::Namespace:
       case NestedNameSpecifier::NamespaceAlias:
       case NestedNameSpecifier::Global:
+      case NestedNameSpecifier::MsSuper:
         llvm_unreachable("Nested-name-specifier must name a type");
       }
 
       // Finally fill in MemberPointerLocInfo fields.
       TL.setStarLoc(Chunk.Loc);
       TL.setClassTInfo(ClsTInfo);
     }
     void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {

lib/Sema/TreeTransform.h

     }
 
     case NestedNameSpecifier::Global:
       // There is no meaningful transformation that one could perform on the
       // global scope.
       SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc());
       break;
 
+  case NestedNameSpecifier::MsSuper:
+    // There is no meaningful transformation that one could perform on the
+    // __super specifier.
+    SS.MakeMsSuper(SemaRef.Context, Q.getBeginLoc(), Q.getEndLoc());
+    break;
+
     case NestedNameSpecifier::TypeSpecWithTemplate:
     case NestedNameSpecifier::TypeSpec: {
       TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType,
                                               FirstQualifierInScope, SS);
 
       if (!TL)
         return NestedNameSpecifierLoc();
 

           << TL.getType() << SS.getRange();
       }
       return NestedNameSpecifierLoc();
     }
     }
 
     // The qualifier-in-scope and object type only apply to the leftmost entity.
     FirstQualifierInScope = nullptr;
     ObjectType = QualType();
   }
 
   // Don't rebuild the nested-name-specifier if we don't have to.
   if (SS.getScopeRep() == NNS.getNestedNameSpecifier() &&
       !getDerived().AlwaysRebuild())
     return NNS;
 
   // If we can re-use the source-location data from the original
   // nested-name-specifier, do so.
   if (SS.location_size() == NNS.getDataLength() &&
       memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0)
     return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());
 
   // Allocate new nested-name-specifier location information.
   return SS.getWithLocInContext(SemaRef.Context);
 }

lib/Serialization/ASTReader.cpp

       break;
     }
 
     case NestedNameSpecifier::Global: {
       NNS = NestedNameSpecifier::GlobalSpecifier(Context);
       // No associated value, and there can't be a prefix.
       break;
     }
+
+    case NestedNameSpecifier::MsSuper: {
+      NNS = NestedNameSpecifier::MsSuperSpecifier(Context);
+      break;
+    }
+
     }
     Prev = NNS;
   }
   return NNS;
 }
 
 NestedNameSpecifierLoc
 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 

       break;
     }
 
     case NestedNameSpecifier::Global: {
       SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
       Builder.MakeGlobal(Context, ColonColonLoc);
       break;
     }
+
+    case NestedNameSpecifier::MsSuper: {
+      SourceRange Range = ReadSourceRange(F, Record, Idx);
+      Builder.MakeMsSuper(Context, Range.getBegin(), Range.getEnd());
+      break;
+    }
+
     }
   }
   
   return Builder.getWithLocInContext(Context);
 }
 
 SourceRange
 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,

lib/Serialization/ASTWriter.cpp

 
     case NestedNameSpecifier::TypeSpec:
     case NestedNameSpecifier::TypeSpecWithTemplate:
       AddTypeRef(QualType(NNS->getAsType(), 0), Record);
       Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
       break;
 
     case NestedNameSpecifier::Global:
+    case NestedNameSpecifier::MsSuper:
       // Don't need to write an associated value.
       break;
     }
   }
 }
 
 void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
                                           RecordDataImpl &Record) {

     case NestedNameSpecifier::TypeSpec:
     case NestedNameSpecifier::TypeSpecWithTemplate:
       Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
       AddTypeLoc(NNS.getTypeLoc(), Record);
       AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
       break;
 
     case NestedNameSpecifier::Global:
+    case NestedNameSpecifier::MsSuper:
       AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
       break;
     }
   }
 }
 
 void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) {
   TemplateName::NameKind Kind = Name.getKind();

test/SemaCXX/MicrosoftExtensions.cpp

   // expected-note@+2 {{overridden virtual function is here}}
   // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}}
   virtual void SealedFunction() sealed;
 };
 
 // expected-note@+2 {{'SealedType' declared here}}
 // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}}
 struct SealedType sealed : SomeBase {
   // expected-error@+1 {{declaration of 'SealedFunction' overrides a 'sealed' function}}
   virtual void SealedFunction();
 
   // expected-warning@+1 {{'override' keyword is a C++11 extension}}
   virtual void OverrideMe() override;
 };
 
 // expected-error@+1 {{base 'SealedType' is marked 'sealed'}}
 struct InheritFromSealed : SealedType {};
 
 void AfterClassBody() {
   // expected-warning@+1 {{attribute 'deprecated' is ignored, place it after "struct" to apply attribute to type declaration}}
   struct D {} __declspec(deprecated);
 
   struct __declspec(align(4)) S {} __declspec(align(8)) s1;
   S s2;
   _Static_assert(__alignof(S) == 4, "");
   _Static_assert(__alignof(s1) == 8, "");
   _Static_assert(__alignof(s2) == 4, "");
 }
+
+namespace super {
+struct A {
+  void foo(int) {}
+};
+
+struct B {
+  void foo(char) {}
+};
+
+struct C : A {
+  void foo(int i) {
+    __super::foo(i);
+  }
+};
+
+struct D : A, B {
+  void foo() {
+    __super::foo('x');
+  }
+}

tools/libclang/CIndex.cpp

                                       = dyn_cast<TemplateSpecializationType>(T))
       return VisitTemplateName(TST->getTemplateName(), Range.getBegin());
     break;
   }
       
   case NestedNameSpecifier::TypeSpecWithTemplate:
   case NestedNameSpecifier::Global:
   case NestedNameSpecifier::Identifier:
+  case NestedNameSpecifier::MsSuper:
     break;      
   }
   
   return false;
 }
 
 bool 
 CursorVisitor::VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {

     case NestedNameSpecifier::TypeSpecWithTemplate:
       if (Visit(Q.getTypeLoc()))
         return true;
         
       break;
         
     case NestedNameSpecifier::Global:
     case NestedNameSpecifier::Identifier:
+    case NestedNameSpecifier::MsSuper:
       break;              
     }
   }
   
   return false;
 }
 
 bool CursorVisitor::VisitTemplateParameters(

tools/libclang/IndexTypeSourceInfo.cpp

 
   if (!DC)
     DC = Parent->getLexicalDeclContext();
   SourceLocation Loc = NNS.getSourceRange().getBegin();
 
   switch (NNS.getNestedNameSpecifier()->getKind()) {
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Global:
+  case NestedNameSpecifier::MsSuper:
     break;
 
   case NestedNameSpecifier::Namespace:
     handleReference(NNS.getNestedNameSpecifier()->getAsNamespace(),
                     Loc, Parent, DC);
     break;
   case NestedNameSpecifier::NamespaceAlias:
     handleReference(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(),