Improve error recovery around colon.

[sepavloff]

Summary

Parse of nested name specifier is modified so that it properly recovers
if colon is mistyped as double colon in case statement.
This patch fixes PR15133.

[rsmith]

include/clang/Parse/Parser.h

172–181 ↗

(On Diff #7321)

Do we really need this? I would think looking at ColonIsSacred should be enough. That flag is also set for range-based for loops, bit-fields, class base-specifiers, enum underlying type specifiers, and ?:, and in each of these cases we want this behavior.

lib/Parse/ParseExprCXX.cpp

476

Should this be a 'break' rather than a 'return'? We should presumably still annotate the prior tokens as a scope specifier.

test/Parser/recovery.cpp

152–153

These diagnostics could be better. Ideally we'd only issue one error, and it would say something like

'V1' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?

... maybe with a note pointing to the declaration of 'V1'.

160

You don't have any tests for this case:

case V1::  func_1(0);

... which might go down a different path in the parser because it's got an identifier after the '::'.

test/SemaCXX/nested-name-spec.cpp

16

Can you split this change out into a separate patch? Also, it'd be great to fix the diagnostic as described above to more clearly explain the problem:

'ax' cannot appear before '::' because it is not a class, namespace, or scoped enumeration

... with a note pointing to the declaration of 'ax'.

[sepavloff]

Updated patch

[sepavloff]

include/clang/Parse/Parser.h

172–181 ↗

(On Diff #7321)

Remade patch excluding this context info.

lib/Parse/ParseExprCXX.cpp

476

This function doesn't do much after exit from loop, but using 'break' is better of course.

test/Parser/recovery.cpp

152–153

Implemented in this way.

160

Indeed, this case didn't handled properly.

[rsmith]

include/clang/Basic/DiagnosticParseKinds.td

65–66

We already have this: diag::note_declared_at.

lib/Parse/ParseExprCXX.cpp

474

Why do you exclude the ObjectType case here? If we have:

struct S { int n; } s;

int k = true ? s.n :: 0;

... we should issue the correction.

475–476

I don't like coupling this check to the check in ActOnCXXNestedNameSpecifier. If these don't match *exactly*, we can fail to emit a diagnostic for the failed lookup here.

Can you instead pass in a bool *, have ActOnCXXNestedNameSpecifier set it if finds the nested name specifier names something that's not valid on the LHS of a ::, and check that flag here? (And remove IsValidIfFollowedByColon.)

lib/Parse/ParseStmt.cpp

641–648

Please fold these together:

} else if (TryConsumeToken(tok::semi, ColonLoc) ||
           TryConsumeToken(tok::coloncolon, ColonLoc)) {

lib/Sema/SemaCXXScopeSpec.cpp

513

I think we should do this if SS is not set too (that is, if we have an ObjectType, we should perform qualified lookup into it, rather than unqualified lookup).

[sepavloff]

Updated patch according to reviewer's notes.

[sepavloff]

include/clang/Basic/DiagnosticParseKinds.td

65–66

Overlooked it. Thank you for the hint.

lib/Parse/ParseExprCXX.cpp

474

Fixed.

475–476

IsValidIfFollowedByColon is removed, declaration of ActOnCXXNestedNameSpecifier changed accordingly.

lib/Parse/ParseStmt.cpp

641–648

Done.

lib/Sema/SemaCXXScopeSpec.cpp

513

Fixed.

[rsmith]

Sorry for the delay!

include/clang/Basic/DiagnosticParseKinds.td

342–343

Either the second thing here should be %1 (and you pass in tok::colon), or this diagnostic should have a better name. "did you mean ':'?" is not an obvious thing to say about a nested name specifier =)

Also, using %1 will let you merge this with the previous diagnostic.

While you're here, please change unexected to unexpected in both diagnostic names. :)

lib/Parse/ParseExprCXX.cpp

470–483

I think it'd be cleaner to pass a bool *CorrectToColon into ActOnCXXNestedNameSpecifier, and issue the diagnostics there (so this diagnostic is not split into two disparate places). Then, if the flag is set, just fix up the token stream here.

lib/Sema/SemaCXXScopeSpec.cpp

521

This will silently ignore the error if you're in DontReportWrongMember mode and name lookup finds something other than a single result.

526

This should probably be an else. If the caller picks DontReportWrongMember, IdDeclPtr is mandatory as they otherwise wouldn't know whether they're required to emit a diagnostic.

[sepavloff]

Updated patch

[sepavloff]

Thank you for feedback!

include/clang/Basic/DiagnosticParseKinds.td

342–343

Yes, I see. Tried to make more descriptive message.
Also changed typos in diagnostic names :)

lib/Parse/ParseExprCXX.cpp

470–483

This is good approach. Looks like patch becomes more compact.

lib/Sema/SemaCXXScopeSpec.cpp

521

Remade this test.

[rsmith]

This looks great, thanks! Some tiny tweaks, then please commit.

lib/Sema/SemaCXXScopeSpec.cpp

522

This check is redundant: we're already inside an if (!ErrorRecoveryLookup) check.

531

I assume this was supposed to say '::' -> ':' is not allowed?

532

Likewise.

[sepavloff]

Thank you!

2014-04-13 8:25 GMT+07:00 Richard Smith <[e-mail]>:

This looks great, thanks! Some tiny tweaks, then please commit.

Comment at: lib/Sema/SemaCXXScopeSpec.cpp:533
@@ +532,3 @@
+ }
+ // Replacement '::' -> is not allowed, just issue respective error.

+ if (!ErrorRecoveryLookup) {

I assume this was supposed to say '::' -> ':' is not allowed?

Comment at: lib/Sema/SemaCXXScopeSpec.cpp:524
@@ +523,3 @@
+ *IsCorrectedToColon = true;
+ if (!ErrorRecoveryLookup) {

+ Diag(CCLoc, diag::err_nested_name_spec_is_not_class)

This check is redundant: we're already inside an `if
(!ErrorRecoveryLookup)` check.

Comment at: lib/Sema/SemaCXXScopeSpec.cpp:534
@@ +533,3 @@
+ // Replacement '::' -> is not allowed, just issue respective error.
+ if (!ErrorRecoveryLookup) {

+ Diag(R.getNameLoc(), diag::err_expected_class_or_namespace)

Likewise.

http://reviews.llvm.org/D2870

BRANCH

pr15133

ARCANIST PROJECT

clang

[sepavloff]

Committed in revision 206135.

include/clang/Basic/DiagnosticParseKinds.td

def ext_plain_complex : ExtWarn<
   "plain '_Complex' requires a type specifier; assuming '_Complex double'">;
 def ext_integer_complex : Extension<
   "complex integer types are a GNU extension">, InGroup<GNUComplexInteger>;
 def ext_thread_before : Extension<"'__thread' before '%0'">;
 def ext_keyword_as_ident : ExtWarn<
   "keyword '%0' will be made available as an identifier "
   "%select{here|for the remainder of the translation unit}1">,
   InGroup<KeywordCompat>;
 
 def error_empty_enum : Error<"use of empty enum">;
 def err_invalid_sign_spec : Error<"'%0' cannot be signed or unsigned">;
 def err_invalid_short_spec : Error<"'short %0' is invalid">;
 def err_invalid_long_spec : Error<"'long %0' is invalid">;
 def err_invalid_longlong_spec : Error<"'long long %0' is invalid">;
 def err_invalid_complex_spec : Error<"'_Complex %0' is invalid">;
 def err_friend_storage_spec : Error<"'%0' is invalid in friend declarations">;
 
 def ext_ident_list_in_param : Extension<

 def err_use_of_tag_name_without_tag : Error<
   "must use '%1' tag to refer to type %0%select{| in this scope}2">;
 def err_templated_using_directive : Error<
   "cannot template a using directive">;
 def err_templated_using_declaration : Error<
   "cannot template a using declaration">;
 def err_unexected_colon_in_nested_name_spec : Error<
   "unexpected ':' in nested name specifier; did you mean '::'?">;
+def err_unexected_token_in_nested_name_spec : Error<
+  "unexpected '%0' in nested name specifier; did you mean ':'?">;
+def err_nested_name_spec_is_not_class : Error<
+  "%0 cannot appear before '::' because it is not a class"
+  "%select{ or namespace|, namespace, or scoped enumeration}1; did you mean ':'?">;
 def err_bool_redeclaration : Error<
   "redeclaration of C++ built-in type 'bool'">;
 def ext_c11_static_assert : Extension<
   "_Static_assert is a C11-specific feature">, InGroup<C11>;
 def warn_cxx98_compat_static_assert : Warning<
   "static_assert declarations are incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_paren_after_colon_colon : Error<

include/clang/Sema/Sema.h

   bool isAcceptableNestedNameSpecifier(const NamedDecl *SD);
   NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
 
   bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
                                     SourceLocation IdLoc,
                                     IdentifierInfo &II,
                                     ParsedType ObjectType);
 
+  /// \brief Enumerates possible kinds of action taken if an error is found
+  /// while building nested name specifier.
+  enum ErrorRecoveryMode {
+    ReportAll,            ///< Report all errors.
+    DontReport,           ///< Called for error recovery, no diagnostics.
+    DontReportWrongMember ///< No error reported if id is found but is not a
+                          /// namespace/class/enum.
+  };
+
   bool BuildCXXNestedNameSpecifier(Scope *S,
                                    IdentifierInfo &Identifier,
                                    SourceLocation IdentifierLoc,
                                    SourceLocation CCLoc,
                                    QualType ObjectType,
                                    bool EnteringContext,
                                    CXXScopeSpec &SS,
                                    NamedDecl *ScopeLookupResult,
-                                   bool ErrorRecoveryLookup);
+                                   ErrorRecoveryMode RecoveryMode,
+                                   NamedDecl **IdDecl = 0);
 
   /// \brief The parser has parsed a nested-name-specifier 'identifier::'.
   ///
   /// \param S The scope in which this nested-name-specifier occurs.
   ///
   /// \param Identifier The identifier preceding the '::'.
   ///
   /// \param IdentifierLoc The location of the identifier.
   ///
   /// \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 RecoveryMode Specifies what kind of error recovery the method is
+  /// called for.
+  ///
+  /// \param IdDeclPtr If not null, it points to a pointer that is assigned
+  /// declaration of the last identifier before ::, if it is not a
+  /// namespace, class or scoped enum.
+  ///
   /// \returns true if an error occurred, false otherwise.
   bool ActOnCXXNestedNameSpecifier(Scope *S,
                                    IdentifierInfo &Identifier,
                                    SourceLocation IdentifierLoc,
                                    SourceLocation CCLoc,
                                    ParsedType ObjectType,
                                    bool EnteringContext,
-                                   CXXScopeSpec &SS);
+                                   CXXScopeSpec &SS,
+                                   ErrorRecoveryMode RecoveryMode = ReportAll,
+                                   NamedDecl **IdDeclPtr = 0);
 
   ExprResult ActOnDecltypeExpression(Expr *E);
 
   bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
                                            const DeclSpec &DS,
                                            SourceLocation ColonColonLoc);
 
   bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,

lib/Parse/ParseExprCXX.cpp

if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
         return false;
       }
 
       if (LastII)
         *LastII = TemplateId->Name;
 
       // Consume the template-id token.
       ConsumeToken();
-      
       assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
       SourceLocation CCLoc = ConsumeToken();
 
       HasScopeSpecifier = true;
-      
       ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
                                          TemplateId->NumArgs);
       
       if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(),
                                               SS,
                                               TemplateId->TemplateKWLoc,
                                               TemplateId->Template,
                                               TemplateId->TemplateNameLoc,
                                               TemplateId->LAngleLoc,
                                               TemplateArgsPtr,
                                               TemplateId->RAngleLoc,
                                               CCLoc,
                                               EnteringContext)) {
         SourceLocation StartLoc 
           = SS.getBeginLoc().isValid()? SS.getBeginLoc()
                                       : TemplateId->TemplateNameLoc;
         SS.SetInvalid(SourceRange(StartLoc, CCLoc));
       }
 
       continue;
     }
 
-
     // The rest of the nested-name-specifier possibilities start with
     // tok::identifier.
     if (Tok.isNot(tok::identifier))
       break;
 
     IdentifierInfo &II = *Tok.getIdentifierInfo();
 
     // nested-name-specifier:
while (true) {
     if (Next.is(tok::coloncolon)) {
       if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde) &&
           !Actions.isNonTypeNestedNameSpecifier(getCurScope(), SS, Tok.getLocation(),
                                                 II, ObjectType)) {
         *MayBePseudoDestructor = true;
         return false;
       }
 
+      if (ColonIsSacred) {
+        const Token &Next2 = GetLookAheadToken(2);
+        if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) ||
+            Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) {
+          Diag(Next2, diag::err_unexected_token_in_nested_name_spec)
+              << Next2.getName()
+              << FixItHint::CreateReplacement(Next.getLocation(), ":");
+          Token ColonColon;
+          PP.Lex(ColonColon);
+          ColonColon.setKind(tok::colon);
+          PP.EnterToken(ColonColon);
+          break;
+        }
+      }
+
       if (LastII)
         *LastII = &II;
 
       // We have an identifier followed by a '::'. Lookup this name
       // as the name in a nested-name-specifier.
+      Token Identifier = Tok;
       SourceLocation IdLoc = ConsumeToken();
       assert((Tok.is(tok::coloncolon) || Tok.is(tok::colon)) &&
              "NextToken() not working properly!");
+      Token ColonColon = Tok;
       SourceLocation CCLoc = ConsumeToken();
 
       CheckForLParenAfterColonColon();
 
-      HasScopeSpecifier = true;
+      Sema::ErrorRecoveryMode ErrMode =
+          ColonIsSacred ? Sema::DontReportWrongMember : Sema::ReportAll;
+      NamedDecl *IdDecl = 0;
       if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(), II, IdLoc, CCLoc,
-                                              ObjectType, EnteringContext, SS))
+                                              ObjectType, EnteringContext, SS,
+                                              ErrMode, &IdDecl)) {
+        // Identifier is not recognized as a nested name, but we can have
+        // mistyped '::' instead of ':'.
+        if (ColonIsSacred && IdDecl) {
+          Diag(CCLoc, diag::err_nested_name_spec_is_not_class)
+              << &II << getLangOpts().CPlusPlus
+              << FixItHint::CreateReplacement(CCLoc, ":");
+          Diag(IdDecl->getLocation(), diag::note_declared_at);
+          ColonColon.setKind(tok::colon);
+          PP.EnterToken(Tok);
+          PP.EnterToken(ColonColon);
+          Tok = Identifier;
+          break;
+        }
         SS.SetInvalid(SourceRange(IdLoc, CCLoc));
-      
+      }
+      HasScopeSpecifier = true;
       continue;
     }
 
     CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
 
     // nested-name-specifier:
     //   type-name '<'
     if (Next.is(tok::less)) {

lib/Parse/ParseStmt.cpp

if (TryConsumeToken(tok::ellipsis, DotDotDotLoc)) {
       if (RHS.isInvalid()) {
         SkipUntil(tok::colon, StopAtSemi);
         return StmtError();
       }
     }
 
     ColonProtection.restore();
 
     if (TryConsumeToken(tok::colon, ColonLoc)) {
-    } else if (TryConsumeToken(tok::semi, ColonLoc)) {
-      // Treat "case blah;" as a typo for "case blah:".
+    } else if (TryConsumeToken(tok::semi, ColonLoc) ||
+               TryConsumeToken(tok::coloncolon, ColonLoc)) {
+      // Treat "case blah;" or "case blah::" as a typo for "case blah:".
       Diag(ColonLoc, diag::err_expected_after)
           << "'case'" << tok::colon
           << FixItHint::CreateReplacement(ColonLoc, ":");
     } else {
       SourceLocation ExpectedLoc = PP.getLocForEndOfToken(PrevTokLocation);
       Diag(ExpectedLoc, diag::err_expected_after)
           << "'case'" << tok::colon
           << FixItHint::CreateInsertion(ExpectedLoc, ":");
       ColonLoc = ExpectedLoc;
     }
 
     StmtResult Case =

lib/Parse/ParseTemplate.cpp

 ///
 ///       template-argument-list: [C++ 14.2]
 ///         template-argument
 ///         template-argument-list ',' template-argument
 bool
 Parser::ParseTemplateArgumentList(TemplateArgList &TemplateArgs) {
   // Template argument lists are constant-evaluation contexts.
   EnterExpressionEvaluationContext EvalContext(Actions,Sema::ConstantEvaluated);
+  ColonProtectionRAIIObject ColonProtection(*this, false);
 
   do {
     ParsedTemplateArgument Arg = ParseTemplateArgument();
     SourceLocation EllipsisLoc;
     if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
       Arg = Actions.ActOnPackExpansion(Arg, EllipsisLoc);
 
     if (Arg.isInvalid()) {

lib/Sema/SemaCXXScopeSpec.cpp

 };
 
 }
 
 /// \brief Build a new nested-name-specifier for "identifier::", as described
 /// by ActOnCXXNestedNameSpecifier.
 ///
 /// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in
-/// that it contains an extra parameter \p ScopeLookupResult, which provides
-/// the result of name lookup within the scope of the nested-name-specifier
-/// that was computed at template definition time.
-///
-/// If ErrorRecoveryLookup is true, then this call is used to improve error
-/// recovery.  This means that it should not emit diagnostics, it should
-/// just return true on failure.  It also means it should only return a valid
-/// scope if it *knows* that the result is correct.  It should not return in a
-/// dependent context, for example. Nor will it extend \p SS with the scope
-/// specifier.
+/// that it contains an extra parameter \p ScopeLookupResult.
+///
+/// \param S Scope in which the nested-name-specifier occurs.
+/// \param Identifier Identifier in the sequence "identifier" "::".
+/// \param IdentifierLoc Location of the \p Identifier.
+/// \param CCLoc Location of "::" following Identifier.
+/// \param ObjectType Type of postfix expression if the nested-name-specifier
+///        occurs in construct like: <tt>ptr->nns::f</tt>.
+/// \param EnteringContext If true, enter the context specified by the
+///        nested-name-specifier.
+/// \param SS Optional nested name specifier preceding the identifier.
+/// \param ScopeLookupResult Provides the result of name lookup within the
+///        scope of the nested-name-specifier that was computed at template
+///        definition time.
+/// \param RecoveryMode Specifies if the method is called to improve error
+///        recovery and what kind of recovery is performed.
+/// \param IdDeclPtr If not null, it points to a pointer that is assigned
+///        declaration of the last identifier before ::, if it is not a
+///        namespace, class or scoped enum.
+///
+/// If \p RecoveryMode equals to \p DontReport, then this call is used to
+/// improve error recovery.  This means that it should not emit diagnostics, it
+/// should just return true on failure.  It also means it should only return a
+/// valid scope if it *knows* that the result is correct.  It should not return
+/// in a dependent context, for example. Nor will it extend \p SS with the
+/// scope specifier.
+/// If \p RecoveryMode is \p ReportAll, all errors are diagnosed. Value
+/// \p DontReportWrongMember acts similarly except when identifier is not a
+/// namespace/class/enum, but is found as other entity. In this case diagnostics
+/// is not emitted, this should be done by caller. This mode is helpful for
+/// error recovery in cases when ':' is can be mistyped as '::', for instance in
+/// case statement: <tt>case AClass::AVal:: break;</tt>.
 bool Sema::BuildCXXNestedNameSpecifier(Scope *S,
                                        IdentifierInfo &Identifier,
                                        SourceLocation IdentifierLoc,
                                        SourceLocation CCLoc,
                                        QualType ObjectType,
                                        bool EnteringContext,
                                        CXXScopeSpec &SS,
                                        NamedDecl *ScopeLookupResult,
-                                       bool ErrorRecoveryLookup) {
+                                       ErrorRecoveryMode RecoveryMode,
+                                       NamedDecl **IdDeclPtr) {
   LookupResult Found(*this, &Identifier, IdentifierLoc, 
                      LookupNestedNameSpecifierName);
 
   // Determine where to perform name lookup
   DeclContext *LookupCtx = 0;
   bool isDependent = false;
   if (!ObjectType.isNull()) {
     // This nested-name-specifier occurs in a member access expression, e.g.,
     // x->B::f, and we are looking into the type of the object.
     assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
     LookupCtx = computeDeclContext(ObjectType);
     isDependent = ObjectType->isDependentType();
   } else if (SS.isSet()) {
     // This nested-name-specifier occurs after another nested-name-specifier,
     // so look into the context associated with the prior nested-name-specifier.
     LookupCtx = computeDeclContext(SS, EnteringContext);
     isDependent = isDependentScopeSpecifier(SS);
     Found.setContextRange(SS.getRange());
   }
 
-
   bool ObjectTypeSearchedInScope = false;
   if (LookupCtx) {
     // Perform "qualified" name lookup into the declaration context we
     // computed, which is either the type of the base of a member access
     // expression or the declaration context associated with a prior
     // nested-name-specifier.
 
     // The declaration context must be complete.
bool Sema::BuildCXXNestedNameSpecifier(Scope *S,
 
   // If we performed lookup into a dependent context and did not find anything,
   // that's fine: just build a dependent nested-name-specifier.
   if (Found.empty() && isDependent &&
       !(LookupCtx && LookupCtx->isRecord() &&
         (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
          !cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases()))) {
     // Don't speculate if we're just trying to improve error recovery.
-    if (ErrorRecoveryLookup)
+    if (RecoveryMode == DontReport)
       return true;
-    
     // We were not able to compute the declaration context for a dependent
     // base object type or prior nested-name-specifier, so this
     // nested-name-specifier refers to an unknown specialization. Just build
     // a dependent nested-name-specifier.
     SS.Extend(Context, &Identifier, IdentifierLoc, CCLoc);
     return false;
-  } 
-  
+  }
   // FIXME: Deal with ambiguities cleanly.
 
-  if (Found.empty() && !ErrorRecoveryLookup && !getLangOpts().MSVCCompat) {
+  if (Found.empty() && RecoveryMode != DontReport) {
+    // If identifier is not found as class-name-or-namespace-name, but is found
+    // as other entity, don't look for typos if caller processes such errors.
+    LookupResult R(*this, Found.getLookupNameInfo(), LookupOrdinaryName);
+    if (LookupCtx)
+      LookupQualifiedName(R, LookupCtx);
+    else if (S && !isDependent)
+      LookupName(R, S);
+    if (!R.empty()) {
+      if (RecoveryMode == ReportAll)
+        Diag(R.getNameLoc(), diag::err_expected_class_or_namespace)
+            << &Identifier << getLangOpts().CPlusPlus;
+      if (NamedDecl *ND = R.getAsSingle<NamedDecl>()) {
+        if (RecoveryMode == ReportAll)
+          Diag(ND->getLocation(),
+               diag::note_expected_class_or_namespace_declared_here)
+              << &Identifier;
+        if (IdDeclPtr)
+          *IdDeclPtr = ND;
+      }
+      return true;
+    }
+  }
+
+  if (Found.empty() && RecoveryMode != DontReport &&
+      !getLangOpts().MSVCCompat) {
     // We haven't found anything, and we're not recovering from a
     // different kind of error, so look for typos.
     DeclarationName Name = Found.getLookupName();
     NestedNameSpecifierValidatorCCC Validator(*this);
     Found.clear();
     if (TypoCorrection Corrected =
             CorrectTypo(Found.getLookupNameInfo(), Found.getLookupKind(), S,
                         &SS, Validator, LookupCtx, EnteringContext)) {
if (!ObjectType.isNull() && !ObjectTypeSearchedInScope &&
         OuterDecl = ScopeLookupResult;
 
       if (isAcceptableNestedNameSpecifier(OuterDecl) &&
           OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() &&
           (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) ||
            !Context.hasSameType(
                             Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)),
                                Context.getTypeDeclType(cast<TypeDecl>(SD))))) {
-         if (ErrorRecoveryLookup)
+         if (RecoveryMode == DontReport)
            return true;
 
          Diag(IdentifierLoc, 
               diag::err_nested_name_member_ref_lookup_ambiguous)
            << &Identifier;
          Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type)
            << ObjectType;
          Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope);
 
          // Fall through so that we'll pick the name we found in the object
          // type, since that's probably what the user wanted anyway.
        }
     }
 
-    // If we're just performing this lookup for error-recovery purposes, 
+    // If we're just performing this lookup for error-recovery purposes,
     // don't extend the nested-name-specifier. Just return now.
-    if (ErrorRecoveryLookup)
+    if (RecoveryMode == DontReport)
       return false;
     
     if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD)) {
       SS.Extend(Context, Namespace, IdentifierLoc, CCLoc);
       return false;
     }
 
     if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD)) {
if (isAcceptableNestedNameSpecifier(SD)) {
 
     SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
               CCLoc);
     return false;
   }
 
   // Otherwise, we have an error case.  If we don't want diagnostics, just
   // return an error now.
-  if (ErrorRecoveryLookup)
+  if (RecoveryMode == DontReport)
     return true;
 
   // If we didn't find anything during our lookup, try again with
   // ordinary name lookup, which can help us produce better error
   // messages.
   if (Found.empty()) {
     Found.clear(LookupOrdinaryName);
     LookupName(Found, S);

 }
 
 bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
                                        IdentifierInfo &Identifier,
                                        SourceLocation IdentifierLoc,
                                        SourceLocation CCLoc,
                                        ParsedType ObjectType,
                                        bool EnteringContext,
-                                       CXXScopeSpec &SS) {
+                                       CXXScopeSpec &SS,
+                                       ErrorRecoveryMode ErrMode,
+                                       NamedDecl **IdDeclPtr) {
   if (SS.isInvalid())
     return true;
-  
   return BuildCXXNestedNameSpecifier(S, Identifier, IdentifierLoc, CCLoc,
                                      GetTypeFromParser(ObjectType),
                                      EnteringContext, SS, 
-                                     /*ScopeLookupResult=*/0, false);
+                                     /*ScopeLookupResult=*/0, ErrMode,
+                                     IdDeclPtr);
 }
 
 bool Sema::ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
                                                const DeclSpec &DS,
                                                SourceLocation ColonColonLoc) {
   if (SS.isInvalid() || DS.getTypeSpecType() == DeclSpec::TST_error)
     return true;
 
bool Sema::IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
                                      ParsedType ObjectType,
                                      bool EnteringContext) {
   if (SS.isInvalid())
     return false;
   
   return !BuildCXXNestedNameSpecifier(S, Identifier, IdentifierLoc, ColonLoc,
                                       GetTypeFromParser(ObjectType),
                                       EnteringContext, SS, 
-                                      /*ScopeLookupResult=*/0, true);
+                                      /*ScopeLookupResult=*/0,
+                                      DontReport);
 }
 
+
 bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
                                        CXXScopeSpec &SS,
                                        SourceLocation TemplateKWLoc,
                                        TemplateTy Template,
                                        SourceLocation TemplateNameLoc,
                                        SourceLocation LAngleLoc,
                                        ASTTemplateArgsPtr TemplateArgsIn,
                                        SourceLocation RAngleLoc,

lib/Sema/SemaDecl.cpp

Sema::NameClassification Sema::ClassifyName(Scope *S,
                                             CXXScopeSpec &SS,
                                             IdentifierInfo *&Name,
                                             SourceLocation NameLoc,
                                             const Token &NextToken,
                                             bool IsAddressOfOperand,
                                             CorrectionCandidateCallback *CCC) {
   DeclarationNameInfo NameInfo(Name, NameLoc);
   ObjCMethodDecl *CurMethod = getCurMethodDecl();
-  
   if (NextToken.is(tok::coloncolon)) {
     BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(),
-                                QualType(), false, SS, 0, false);
-    
+                                QualType(), false, SS, 0, ReportAll);
   }
-      
   LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
   LookupParsedName(Result, S, &SS, !CurMethod);
-  
   // Perform lookup for Objective-C instance variables (including automatically 
   // synthesized instance variables), if we're in an Objective-C method.
   // FIXME: This lookup really, really needs to be folded in to the normal
   // unqualified lookup mechanism.
   if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
     ExprResult E = LookupInObjCMethod(Result, S, Name, true);
     if (E.get() || E.isInvalid())
       return E;

lib/Sema/TreeTransform.h

while (!Qualifiers.empty()) {
 
     switch (QNNS->getKind()) {
     case NestedNameSpecifier::Identifier:
       if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/0,
                                               *QNNS->getAsIdentifier(),
                                               Q.getLocalBeginLoc(),
                                               Q.getLocalEndLoc(),
                                               ObjectType, false, SS,
-                                              FirstQualifierInScope, false))
+                                              FirstQualifierInScope,
+                                              Sema::ReportAll))
         return NestedNameSpecifierLoc();
 
       break;
 
     case NestedNameSpecifier::Namespace: {
       NamespaceDecl *NS
         = cast_or_null<NamespaceDecl>(
                                     getDerived().TransformDecl(

test/Parser/recovery.cpp

 struct MissingSemiThenTemplate2 {} // expected-error {{expected ';' after struct}}
 Foo<int> missingSemiBeforeFunctionReturningTemplateId2();
 
 namespace PR17084 {
 enum class EnumID {};
 template <typename> struct TempID;
 template <> struct TempID<BadType> : BadType, EnumID::Garbage; // expected-error{{use of undeclared identifier 'BadType'}}
 }
+
+namespace pr15133 {
+  namespace ns {
+    const int V1 = 1;   // expected-note {{declared here}}
+  }
+  struct C1 {
+    enum E1 { V2 = 2 }; // expected-note {{declared here}}
+    static const int V3 = 3; // expected-note {{declared here}}
+  };
+  enum E2 {
+    V4 = 4,   // expected-note {{declared here}}
+    V6        // expected-note {{declared here}}
+  };
+  enum class EC3 { V0 = 0, V5 = 5 }; // expected-note {{declared here}}
+  void func_3();
+
+  void func_1(int x) {
+    switch(x) {
+    case 0: break;
+    case ns::V1:: break; // expected-error{{'V1' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?}}
+    case C1::V2:: break; // expected-error{{'V2' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?}}
+    case C1::V3:: break; // expected-error{{'V3' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?}}
+    case V4:: break; // expected-error{{'V4' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?}}
+    case V6:: func_3();   // expected-error{{'V6' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?}}
+    }
+  }
+  void func_2(EC3 x) {
+    switch(x) {
+    case EC3::V0:  break;
+    case EC3::V5:: break; // expected-error{{'V5' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?}}
+    }
+  }
+
+  template<class T> struct TS1 {
+    typedef int A;
+  };
+  template<class T> void func(int x) {
+    switch(x) {
+    case TS1<T>::A:: break;  // expected-error{{expected unqualified-id}}
+    }
+  };
+  void mainf() {
+    func<int>(1);
+  }
+
+  struct S {
+    static int n;  // expected-note{{declared here}}
+    int nn;        // expected-note 2 {{declared here}}
+  };
+
+  int func_3(int x) {
+    return x ? S::n :: 0;  // expected-error{{'n' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?}}
+  }
+  int func_4(int x, S &s) {
+    return x ? s.nn :: x;  // expected-error{{'nn' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?}}
+  }
+  int func_5(int x, S &s) {
+    return x ? s.nn :: S::n;  // expected-error{{'nn' cannot appear before '::' because it is not a class, namespace, or scoped enumeration; did you mean ':'?}}
+  }
+
+  struct S2 {
+    struct S3;
+  };
+
+  struct S2 :: S3 :: public S2 {  // expected-error{{unexpected 'public' in nested name specifier; did you mean ':'?}}
+  };
+}

test/SemaCXX/nested-name-spec.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify -fblocks %s 
 namespace A {
   struct C {
     static int cx;
 
     static int cx2;
 
     static int Ag1();
     static int Ag2();
   };
-  int ax;
+  int ax; // expected-note {{'ax' declared here}}
   void Af();
 }
 
 A:: ; // expected-error {{expected unqualified-id}}
-// FIXME: there is a member 'ax'; it's just not a class.
-::A::ax::undef ex3; // expected-error {{no member named 'ax'}}
+::A::ax::undef ex3; // expected-error {{'ax' is not a class, namespace, or scoped enumeration}}
 A::undef1::undef2 ex4; // expected-error {{no member named 'undef1'}}
 
 int A::C::Ag1() { return 0; }
 
 static int A::C::Ag2() { return 0; } // expected-error{{'static' can}}
 
 int A::C::cx = 17;