Remove tabs, and whitespace cleanups.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@81346 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 49 insertions, 51 deletions

diff --git a/lib/Parse/ParseExprCXX.cpp b/lib/Parse/ParseExprCXX.cpp
index a248a5dbee..a68ed6a803 100644
--- a/lib/Parse/ParseExprCXX.cpp
+++ b/lib/Parse/ParseExprCXX.cpp
@@ -16,10 +16,10 @@
 #include "clang/Parse/DeclSpec.h"
 using namespace clang;
 
-/// \brief Parse global scope or nested-name-specifier if present. 
+/// \brief Parse global scope or nested-name-specifier if present.
 ///
 /// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
-/// may be preceded by '::'). Note that this routine will not parse ::new or 
+/// may be preceded by '::'). Note that this routine will not parse ::new or
 /// ::delete; it will just leave them in the token stream.
 ///
 ///       '::'[opt] nested-name-specifier
@@ -32,10 +32,10 @@ using namespace clang;
 ///         nested-name-specifier 'template'[opt] simple-template-id '::'
 ///
 ///
-/// \param SS the scope specifier that will be set to the parsed 
+/// \param SS the scope specifier that will be set to the parsed
 /// nested-name-specifier (or empty)
 ///
-/// \param ObjectType if this nested-name-specifier is being parsed following 
+/// \param ObjectType if this nested-name-specifier is being parsed following
 /// the "." or "->" of a member access expression, this parameter provides the
 /// type of the object whose members are being accessed.
 ///
@@ -48,7 +48,7 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
                                             bool EnteringContext) {
   assert(getLang().CPlusPlus &&
          "Call sites of this function should be guarded by checking for C++");
-  
+
   if (Tok.is(tok::annot_cxxscope)) {
     SS.setScopeRep(Tok.getAnnotationValue());
     SS.setRange(Tok.getAnnotationRange());
@@ -63,7 +63,7 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
     tok::TokenKind NextKind = NextToken().getKind();
     if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
       return false;
-    
+
     // '::' - Global scope qualifier.
     SourceLocation CCLoc = ConsumeToken();
     SS.setBeginLoc(CCLoc);
@@ -86,7 +86,7 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
       // seen a leading '::' or part of a nested-name-specifier.
       ObjectType = 0;
     }
-    
+
     // nested-name-specifier:
     //   nested-name-specifier 'template'[opt] simple-template-id '::'
 
@@ -100,14 +100,14 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
         break;
 
       SourceLocation TemplateKWLoc = ConsumeToken();
-      
+
       if (Tok.isNot(tok::identifier)) {
-        Diag(Tok.getLocation(), 
+        Diag(Tok.getLocation(),
              diag::err_id_after_template_in_nested_name_spec)
           << SourceRange(TemplateKWLoc);
         break;
       }
-      
+
       if (NextToken().isNot(tok::less)) {
         Diag(NextToken().getLocation(),
              diag::err_less_after_template_name_in_nested_name_spec)
@@ -115,8 +115,8 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
           << SourceRange(TemplateKWLoc, Tok.getLocation());
         break;
       }
-      
-      TemplateTy Template 
+
+      TemplateTy Template
         = Actions.ActOnDependentTemplateName(TemplateKWLoc,
                                              *Tok.getIdentifierInfo(),
                                              Tok.getLocation(), SS,
@@ -126,40 +126,40 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
       if (AnnotateTemplateIdToken(Template, TNK_Dependent_template_name,
                                   &SS, TemplateKWLoc, false))
         break;
-      
+
       continue;
     }
-    
+
     if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
-      // We have 
+      // We have
       //
       //   simple-template-id '::'
       //
       // So we need to check whether the simple-template-id is of the
       // right kind (it should name a type or be dependent), and then
       // convert it into a type within the nested-name-specifier.
-      TemplateIdAnnotation *TemplateId 
+      TemplateIdAnnotation *TemplateId
         = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
 
-      if (TemplateId->Kind == TNK_Type_template || 
+      if (TemplateId->Kind == TNK_Type_template ||
           TemplateId->Kind == TNK_Dependent_template_name) {
         AnnotateTemplateIdTokenAsType(&SS);
 
-        assert(Tok.is(tok::annot_typename) && 
+        assert(Tok.is(tok::annot_typename) &&
                "AnnotateTemplateIdTokenAsType isn't working");
         Token TypeToken = Tok;
         ConsumeToken();
         assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
         SourceLocation CCLoc = ConsumeToken();
-        
+
         if (!HasScopeSpecifier) {
           SS.setBeginLoc(TypeToken.getLocation());
           HasScopeSpecifier = true;
         }
-        
+
         if (TypeToken.getAnnotationValue())
           SS.setScopeRep(
-            Actions.ActOnCXXNestedNameSpecifier(CurScope, SS, 
+            Actions.ActOnCXXNestedNameSpecifier(CurScope, SS,
                                                 TypeToken.getAnnotationValue(),
                                                 TypeToken.getAnnotationRange(),
                                                 CCLoc));
@@ -168,7 +168,7 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
         SS.setEndLoc(CCLoc);
         continue;
       }
-      
+
       assert(false && "FIXME: Only type template names supported here");
     }
 
@@ -191,22 +191,22 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
       SourceLocation IdLoc = ConsumeToken();
       assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
       SourceLocation CCLoc = ConsumeToken();
-      
+
       if (!HasScopeSpecifier) {
         SS.setBeginLoc(IdLoc);
         HasScopeSpecifier = true;
       }
-      
+
       if (SS.isInvalid())
         continue;
-      
+
       SS.setScopeRep(
         Actions.ActOnCXXNestedNameSpecifier(CurScope, SS, IdLoc, CCLoc, II,
                                             ObjectType, EnteringContext));
       SS.setEndLoc(CCLoc);
       continue;
     }
-    
+
     // nested-name-specifier:
     //   type-name '<'
     if (Next.is(tok::less)) {
@@ -234,7 +234,7 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
     // nested-name-specifier, so we're done.
     break;
   }
-    
+
   return HasScopeSpecifier;
 }
 
@@ -337,17 +337,17 @@ Parser::OwningExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
   }
 
   case tok::annot_template_id: {
-    TemplateIdAnnotation *TemplateId 
+    TemplateIdAnnotation *TemplateId
       = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
     assert((TemplateId->Kind == TNK_Function_template ||
             TemplateId->Kind == TNK_Dependent_template_name) &&
            "A template type name is not an ID expression");
 
-    ASTTemplateArgsPtr TemplateArgsPtr(Actions, 
+    ASTTemplateArgsPtr TemplateArgsPtr(Actions,
                                        TemplateId->getTemplateArgs(),
                                        TemplateId->getTemplateArgIsType(),
                                        TemplateId->NumArgs);
-    
+
     OwningExprResult Result
       = Actions.ActOnTemplateIdExpr(TemplateTy::make(TemplateId->Template),
                                     TemplateId->TemplateNameLoc,
@@ -403,11 +403,11 @@ Parser::OwningExprResult Parser::ParseCXXCasts() {
     return ExprError();
 
   OwningExprResult Result = ParseExpression();
-  
+
   // Match the ')'.
   if (Result.isInvalid())
     SkipUntil(tok::r_paren);
-  
+
   if (Tok.is(tok::r_paren))
     RParenLoc = ConsumeParen();
   else
@@ -455,11 +455,11 @@ Parser::OwningExprResult Parser::ParseCXXTypeid() {
                                     Ty.get(), RParenLoc);
   } else {
     // C++0x [expr.typeid]p3:
-    //   When typeid is applied to an expression other than an lvalue of a 
-    //   polymorphic class type [...] The expression is an unevaluated 
+    //   When typeid is applied to an expression other than an lvalue of a
+    //   polymorphic class type [...] The expression is an unevaluated
     //   operand (Clause 5).
     //
-    // Note that we can't tell whether the expression is an lvalue of a 
+    // Note that we can't tell whether the expression is an lvalue of a
     // polymorphic class type until after we've parsed the expression, so
     // we the expression is potentially potentially evaluated.
     EnterExpressionEvaluationContext Unevaluated(Actions,
@@ -654,12 +654,12 @@ void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
   const char *PrevSpec;
   unsigned DiagID;
   SourceLocation Loc = Tok.getLocation();
-  
+
   switch (Tok.getKind()) {
   case tok::identifier:   // foo::bar
   case tok::coloncolon:   // ::foo::bar
     assert(0 && "Annotation token should already be formed!");
-  default: 
+  default:
     assert(0 && "Not a simple-type-specifier token!");
     abort();
 
@@ -669,7 +669,7 @@ void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
                        Tok.getAnnotationValue());
     break;
   }
-    
+
   // builtin types
   case tok::kw_short:
     DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID);
@@ -710,7 +710,7 @@ void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
   case tok::kw_bool:
     DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID);
     break;
-  
+
   // GNU typeof support.
   case tok::kw_typeof:
     ParseTypeofSpecifier(DS);
@@ -747,7 +747,7 @@ bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
     Diag(Tok, diag::err_operator_missing_type_specifier);
     return true;
   }
-  
+
   while (ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID)) ;
 
   return false;
@@ -878,7 +878,7 @@ Parser::TypeTy *Parser::ParseConversionFunctionId(SourceLocation *EndLoc) {
 
 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
 /// memory in a typesafe manner and call constructors.
-/// 
+///
 /// This method is called to parse the new expression after the optional :: has
 /// been already parsed.  If the :: was present, "UseGlobal" is true and "Start"
 /// is its location.  Otherwise, "Start" is the location of the 'new' token.
@@ -1087,8 +1087,7 @@ Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
   return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, move(Operand));
 }
 
-static UnaryTypeTrait UnaryTypeTraitFromTokKind(tok::TokenKind kind)
-{
+static UnaryTypeTrait UnaryTypeTraitFromTokKind(tok::TokenKind kind) {
   switch(kind) {
   default: assert(false && "Not a known unary type trait.");
   case tok::kw___has_nothrow_assign:      return UTT_HasNothrowAssign;
@@ -1116,8 +1115,7 @@ static UnaryTypeTrait UnaryTypeTraitFromTokKind(tok::TokenKind kind)
 ///       primary-expression:
 /// [GNU]             unary-type-trait '(' type-id ')'
 ///
-Parser::OwningExprResult Parser::ParseUnaryTypeTrait()
-{
+Parser::OwningExprResult Parser::ParseUnaryTypeTrait() {
   UnaryTypeTrait UTT = UnaryTypeTraitFromTokKind(Tok.getKind());
   SourceLocation Loc = ConsumeToken();
 
@@ -1172,7 +1170,7 @@ Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
   // parsing a cast-expression), and then we re-introduce the cached tokens
   // into the token stream and parse them appropriately.
 
-  ParenParseOption ParseAs;  
+  ParenParseOption ParseAs;
   CachedTokens Toks;
 
   // Store the tokens of the parentheses. We will parse them after we determine
@@ -1204,7 +1202,7 @@ Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
     ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
   }
 
-  // The current token should go after the cached tokens. 
+  // The current token should go after the cached tokens.
   Toks.push_back(Tok);
   // Re-enter the stored parenthesized tokens into the token stream, so we may
   // parse them now.
@@ -1227,7 +1225,7 @@ Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
       ExprType = CompoundLiteral;
       return ParseCompoundLiteralExpression(Ty.get(), LParenLoc, RParenLoc);
     }
-    
+
     // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
     assert(ParseAs == CastExpr);
 
@@ -1238,11 +1236,11 @@ Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
 
     // Result is what ParseCastExpression returned earlier.
     if (!Result.isInvalid())
-      Result = Actions.ActOnCastExpr(CurScope, LParenLoc, CastTy, RParenLoc, 
+      Result = Actions.ActOnCastExpr(CurScope, LParenLoc, CastTy, RParenLoc,
                                      move(Result));
     return move(Result);
   }
-  
+
   // Not a compound literal, and not followed by a cast-expression.
   assert(ParseAs == SimpleExpr);
 
@@ -1256,7 +1254,7 @@ Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
     SkipUntil(tok::r_paren);
     return ExprError();
   }
-  
+
   if (Tok.is(tok::r_paren))
     RParenLoc = ConsumeParen();
   else