maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert accidential "[MSVC] Late parsing of in-class defined member functions in template" 

This reverts commit 0253605771b8bd9d414aba74fe2742c730d6fd1a.

llvm-svn: 272776
This commit is contained in:
Alexey Bataev 2016-06-15 11:24:54 +00:00
parent b46cdeae9f
commit 61deb4dadc
22 changed files with 12 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
clang/include/clang-c/Index.h
View File

@ -2305,11 +2305,7 @@ enum CXCursorKind {
*/
CXCursor_OMPTargetUpdateDirective = 265,
/** \brief A MS-specific late parsed compound statement.
*/
CXCursor_MSLateParsedCompoundStmt = 266,
CXCursor_LastStmt = CXCursor_MSLateParsedCompoundStmt,
CXCursor_LastStmt = CXCursor_OMPTargetUpdateDirective,
/**
* \brief Cursor that represents the translation unit itself.

1
clang/include/clang/AST/RecursiveASTVisitor.h
View File

@ -2332,7 +2332,6 @@ DEF_TRAVERSE_STMT(SEHExceptStmt, {})
DEF_TRAVERSE_STMT(SEHFinallyStmt, {})
DEF_TRAVERSE_STMT(SEHLeaveStmt, {})
DEF_TRAVERSE_STMT(CapturedStmt, { TRY_TO(TraverseDecl(S->getCapturedDecl())); })
DEF_TRAVERSE_STMT(MSLateParsedCompoundStmt, {})
DEF_TRAVERSE_STMT(CXXOperatorCallExpr, {})
DEF_TRAVERSE_STMT(OpaqueValueExpr, {})

46
clang/include/clang/AST/StmtCXX.h
View File

@ -18,7 +18,6 @@
#include "clang/AST/Expr.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/Stmt.h"
#include "clang/Lex/Token.h"
#include "llvm/Support/Compiler.h"
namespace clang {
@ -418,51 +417,6 @@ public:
}
};
/// This represents a group of statements like { stmt stmt } that must be parsed
/// only during instantiation. Required for better MSVC compatibility.
class MSLateParsedCompoundStmt final
: public Stmt,
private llvm::TrailingObjects<MSLateParsedCompoundStmt, Token> {
friend class TrailingObjects;
friend class ASTStmtReader;
SourceLocation LBraceLoc, RBraceLoc;
StringRef StringRep;
unsigned NumToks;
MSLateParsedCompoundStmt()
: Stmt(MSLateParsedCompoundStmtClass), NumToks(0) {}
/// Set tokens for the statement.
void init(ASTContext &C, SourceLocation LB, SourceLocation RB,
ArrayRef<Token> Tokens, StringRef Rep);
public:
static MSLateParsedCompoundStmt *Create(ASTContext &C, SourceLocation LB,
SourceLocation RB,
ArrayRef<Token> Tokens,
StringRef Rep);
/// Build an empty statement.
static MSLateParsedCompoundStmt *CreateEmpty(ASTContext &C,
unsigned NumTokens);
SourceLocation getLocStart() const LLVM_READONLY { return LBraceLoc; }
SourceLocation getLocEnd() const LLVM_READONLY { return RBraceLoc; }
/// Returns representation of the statement as a string.
StringRef getStringRepresentation() const { return StringRep; }
/// Get list of tokens associated with the statement.
ArrayRef<Token> tokens() const;
child_range children() {
return child_range(child_iterator(), child_iterator());
}
static bool classof(const Stmt *S) {
return S->getStmtClass() == MSLateParsedCompoundStmtClass;
}
};
} // end namespace clang
#endif

1
clang/include/clang/Basic/StmtNodes.td
View File

@ -187,7 +187,6 @@ def SEHExceptStmt : Stmt;
def SEHFinallyStmt : Stmt;
def SEHLeaveStmt : Stmt;
def MSDependentExistsStmt : Stmt;
def MSLateParsedCompoundStmt : Stmt;
// OpenCL Extensions.
def AsTypeExpr : DStmt<Expr>;

2
clang/include/clang/Parse/Parser.h
View File

@ -1181,11 +1181,9 @@ private:
void LexTemplateFunctionForLateParsing(CachedTokens &Toks);
void ParseLateTemplatedFuncDef(LateParsedTemplate &LPT);
void ParseMSVCTemplatedFuncDef(LateParsedTemplate &LPT);
static void LateTemplateParserCallback(void *P, LateParsedTemplate &LPT);
static void LateTemplateParserCleanupCallback(void *P);
static void MSVCTemplateParserCallback(void *P, LateParsedTemplate &LPT);
Sema::ParsingClassState
PushParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface);

5
clang/include/clang/Sema/Sema.h
View File

@ -3507,11 +3507,6 @@ public:
LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
SourceLocation Location,
bool AlwaysCreate);
/// Builds late parsed compound statement or just compound statement in MSVC
/// compatibility mode.
StmtResult ActOnMSLateParsedCompoundStmt(SourceLocation LB, SourceLocation RB,
ArrayRef<Token> Tokens,
StringRef Rep);
VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
SourceLocation StartLoc,

2
clang/include/clang/Serialization/ASTBitCodes.h
View File

@ -1220,8 +1220,6 @@ namespace clang {
STMT_GCCASM,
/// \brief A MS-style AsmStmt record.
STMT_MSASM,
/// \brief A MS-specific late parsed compound statement.
STMT_MS_LATE_PARSED_COMPOUND,
/// \brief A PredefinedExpr record.
EXPR_PREDEFINED,
/// \brief A DeclRefExpr record.

35
clang/lib/AST/StmtCXX.cpp
View File

@ -86,38 +86,3 @@ VarDecl *CXXForRangeStmt::getLoopVariable() {
const VarDecl *CXXForRangeStmt::getLoopVariable() const {
return const_cast<CXXForRangeStmt *>(this)->getLoopVariable();
}
MSLateParsedCompoundStmt *
MSLateParsedCompoundStmt::Create(ASTContext &C, SourceLocation LB,
SourceLocation RB, ArrayRef<Token> Tokens,
StringRef Rep) {
// Allocate space for private variables and initializer expressions.
void *Mem = C.Allocate(totalSizeToAlloc<Token>(Tokens.size()),
llvm::alignOf<MSLateParsedCompoundStmt>());
auto *S = new (Mem) MSLateParsedCompoundStmt();
S->init(C, LB, RB, Tokens, Rep);
return S;
}
MSLateParsedCompoundStmt *
MSLateParsedCompoundStmt::CreateEmpty(ASTContext &C, unsigned NumTokens) {
// Allocate space for private variables and initializer expressions.
void *Mem = C.Allocate(totalSizeToAlloc<Token>(NumTokens),
llvm::alignOf<MSLateParsedCompoundStmt>());
return new (Mem) MSLateParsedCompoundStmt();
}
void MSLateParsedCompoundStmt::init(ASTContext &C, SourceLocation LB,
SourceLocation RB, ArrayRef<Token> Tokens,
StringRef Rep) {
LBraceLoc = LB;
RBraceLoc = RB;
std::copy(Tokens.begin(), Tokens.end(), getTrailingObjects<Token>());
StringRep = Rep.copy(C);
NumToks = Tokens.size();
}
ArrayRef<Token> MSLateParsedCompoundStmt::tokens() const {
return llvm::makeArrayRef(getTrailingObjects<Token>(), NumToks);
}

4
clang/lib/AST/StmtPrinter.cpp
View File

@ -2352,10 +2352,6 @@ void StmtPrinter::VisitCoreturnStmt(CoreturnStmt *S) {
OS << ";";
}
void StmtPrinter::VisitMSLateParsedCompoundStmt(MSLateParsedCompoundStmt *S) {
OS << S->getStringRepresentation();
}
void StmtPrinter::VisitCoawaitExpr(CoawaitExpr *S) {
OS << "co_await ";
PrintExpr(S->getOperand());

5
clang/lib/AST/StmtProfile.cpp
View File

@ -1499,11 +1499,6 @@ void StmtProfiler::VisitCoreturnStmt(const CoreturnStmt *S) {
VisitStmt(S);
}
void StmtProfiler::VisitMSLateParsedCompoundStmt(
const MSLateParsedCompoundStmt *S) {
VisitStmt(S);
}
void StmtProfiler::VisitCoawaitExpr(const CoawaitExpr *S) {
VisitExpr(S);
}

1
clang/lib/CodeGen/CGStmt.cpp
View File

@ -80,7 +80,6 @@ void CodeGenFunction::EmitStmt(const Stmt *S) {
case Stmt::SEHExceptStmtClass:
case Stmt::SEHFinallyStmtClass:
case Stmt::MSDependentExistsStmtClass:
case Stmt::MSLateParsedCompoundStmtClass:
llvm_unreachable("invalid statement class to emit generically");
case Stmt::NullStmtClass:
case Stmt::CompoundStmtClass:

84
clang/lib/Parse/ParseTemplate.cpp
View File

@ -1417,90 +1417,6 @@ void Parser::ParseLateTemplatedFuncDef(LateParsedTemplate &LPT) {
delete *I;
}
void Parser::MSVCTemplateParserCallback(void *P, LateParsedTemplate &LPT) {
((Parser *)P)->ParseMSVCTemplatedFuncDef(LPT);
}
/// \brief Late parse a C++ function template in Microsoft mode.
void Parser::ParseMSVCTemplatedFuncDef(LateParsedTemplate &LPT) {
if (!LPT.D)
return;
// Get the FunctionDecl.
FunctionDecl *FunD = LPT.D->getAsFunction();
// Track template parameter depth.
TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
SmallVector<ParseScope*, 4> TemplateParamScopeStack;
// Get the list of DeclContexts to reenter.
SmallVector<DeclContext*, 4> DeclContextsToReenter;
DeclContext *DD = FunD;
while (DD && !DD->isTranslationUnit()) {
DeclContextsToReenter.push_back(DD);
DD = DD->getLexicalParent();
}
// Reenter template scopes from outermost to innermost.
SmallVectorImpl<DeclContext *>::reverse_iterator II =
DeclContextsToReenter.rbegin();
for (; II != DeclContextsToReenter.rend(); ++II) {
TemplateParamScopeStack.push_back(new ParseScope(this,
Scope::TemplateParamScope));
unsigned NumParamLists =
Actions.ActOnReenterTemplateScope(getCurScope(), cast<Decl>(*II));
CurTemplateDepthTracker.addDepth(NumParamLists);
if (*II != FunD) {
TemplateParamScopeStack.push_back(new ParseScope(this, Scope::DeclScope));
Actions.PushDeclContext(Actions.getCurScope(), *II);
}
}
assert(!LPT.Toks.empty() && "Empty body!");
// Append the current token at the end of the new token stream so that it
// doesn't get lost.
LPT.Toks.push_back(Tok);
PP.EnterTokenStream(LPT.Toks, true);
// Consume the previously pushed token.
ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
assert(Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try) &&
"Inline method not starting with '{', ':' or 'try'");
// Parse the method body. Function body parsing code is similar enough
// to be re-used for method bodies as well.
ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope);
if (Tok.is(tok::kw_try)) {
ParseFunctionTryBlock(LPT.D, FnScope);
} else {
if (Tok.is(tok::colon))
ParseConstructorInitializer(LPT.D);
else
Actions.ActOnDefaultCtorInitializers(LPT.D);
if (Tok.is(tok::l_brace)) {
assert((!isa<FunctionTemplateDecl>(LPT.D) ||
cast<FunctionTemplateDecl>(LPT.D)
->getTemplateParameters()
->getDepth() == TemplateParameterDepth - 1) &&
"TemplateParameterDepth should be greater than the depth of "
"current template being instantiated!");
ParseFunctionStatementBody(LPT.D, FnScope);
Actions.UnmarkAsLateParsedTemplate(FunD);
} else
Actions.ActOnFinishFunctionBody(LPT.D, nullptr);
}
// Exit scopes.
FnScope.Exit();
SmallVectorImpl<ParseScope *>::reverse_iterator I =
TemplateParamScopeStack.rbegin();
for (; I != TemplateParamScopeStack.rend(); ++I)
delete *I;
}
/// \brief Lex a delayed template function for late parsing.
void Parser::LexTemplateFunctionForLateParsing(CachedTokens &Toks) {
tok::TokenKind kind = Tok.getKind();

37
clang/lib/Parse/Parser.cpp
View File

@ -89,8 +89,6 @@ Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies)
PP.addCommentHandler(CommentSemaHandler.get());
PP.setCodeCompletionHandler(*this);
if (getLangOpts().MSVCCompat)
Actions.SetLateTemplateParser(LateTemplateParserCallback, nullptr, this);
}
DiagnosticBuilder Parser::Diag(SourceLocation Loc, unsigned DiagID) {
@ -1055,35 +1053,12 @@ Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D,
Actions.MarkAsLateParsedTemplate(FnD, DP, Toks);
}
return DP;
} else if (getLangOpts().MSVCCompat && Tok.isNot(tok::equal) &&
TemplateInfo.Kind == ParsedTemplateInfo::Template &&
Actions.canDelayFunctionBody(D)) {
// In delayed template parsing mode, for function template we consume the
// tokens and store them for late parsing at the end of the translation
// unit.
MultiTemplateParamsArg TemplateParameterLists(*TemplateInfo.TemplateParams);
ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope);
CachedTokens Toks;
LexTemplateFunctionForLateParsing(Toks);
Decl *Res = Actions.ActOnStartOfFunctionDef(getCurScope(), D,
*TemplateInfo.TemplateParams);
D.complete(Res);
D.getMutableDeclSpec().abort();
StmtResult Body = Actions.ActOnMSLateParsedCompoundStmt(
Toks.begin()->getLocation(), Tok.getLocation(), Toks,
Lexer::getSourceText(
{{Toks.begin()->getLocation(), Tok.getLocation()}, false},
Actions.getASTContext().getSourceManager(), getLangOpts()));
BodyScope.Exit();
return Actions.ActOnFinishFunctionBody(Res, Body.get());
} else if (CurParsedObjCImpl && !TemplateInfo.TemplateParams &&
(Tok.is(tok::l_brace) || Tok.is(tok::kw_try) ||
Tok.is(tok::colon)) &&
Actions.CurContext->isTranslationUnit()) {
}
else if (CurParsedObjCImpl &&
!TemplateInfo.TemplateParams &&
(Tok.is(tok::l_brace) || Tok.is(tok::kw_try) ||
Tok.is(tok::colon)) &&
Actions.CurContext->isTranslationUnit()) {
ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope);
Scope *ParentScope = getCurScope()->getParent();

10
clang/lib/Sema/SemaExpr.cpp
View File

@ -2213,11 +2213,11 @@ Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen);
if (R.empty() && !ADL) {
// if (SS.isEmpty() && getLangOpts().MSVCCompat) {
// if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
// TemplateKWLoc, TemplateArgs))
// return E;
// }
if (SS.isEmpty() && getLangOpts().MSVCCompat) {
if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
TemplateKWLoc, TemplateArgs))
return E;
}
// Don't diagnose an empty lookup for inline assembly.
if (IsInlineAsmIdentifier)

27
clang/lib/Sema/SemaStmt.cpp
View File

@ -3978,30 +3978,3 @@ StmtResult Sema::ActOnCapturedRegionEnd(Stmt *S) {
return Res;
}
StmtResult Sema::ActOnMSLateParsedCompoundStmt(SourceLocation LB,
SourceLocation RB,
ArrayRef<Token> Tokens,
StringRef Rep) {
if (CurContext->isDependentContext())
return MSLateParsedCompoundStmt::Create(getASTContext(), LB, RB, Tokens,
Rep);
QualType CXXThisTy = getCurrentThisType();
assert(!CXXThisTy.isNull());
auto *CXXThisRD = CXXThisTy->castAs<PointerType>()
->getPointeeCXXRecordDecl()
->getCanonicalDecl();
DeclContext *DC = getFunctionLevelDeclContext();
while (auto *PCXXRD = dyn_cast<CXXRecordDecl>(DC)) {
if (PCXXRD->getCanonicalDecl() == CXXThisRD)
break;
DC = DC->getParent();
}
auto *MD = dyn_cast<CXXMethodDecl>(DC);
LateParsedTemplate LPT;
LPT.Toks.append(Tokens.begin(), Tokens.end());
LPT.D = MD;
LateTemplateParser(OpaqueParser, LPT);
return MD->getBody();
}

21
clang/lib/Sema/TreeTransform.h
View File

@ -1292,17 +1292,6 @@ public:
Constraints, Clobbers, Exprs, EndLoc);
}
/// Build a new compound statement.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildMSLateParsedCompoundStmt(SourceLocation LB,
SourceLocation RB,
ArrayRef<Token> Tokens,
StringRef Rep) {
return getSema().ActOnMSLateParsedCompoundStmt(LB, RB, Tokens, Rep);
}
/// \brief Build a new co_return statement.
///
/// By default, performs semantic analysis to build the new statement.
@ -6617,16 +6606,6 @@ TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
TransformedExprs, S->getEndLoc());
}
template <typename Derived>
StmtResult TreeTransform<Derived>::TransformMSLateParsedCompoundStmt(
MSLateParsedCompoundStmt *S) {
if (SemaRef.CurContext->isDependentContext())
return S;
return getDerived().RebuildMSLateParsedCompoundStmt(
S->getLocStart(), S->getLocEnd(), S->tokens(),
S->getStringRepresentation());
}
// C++ Coroutines TS
template<typename Derived>

20
clang/lib/Serialization/ASTReaderStmt.cpp
View File

@ -382,21 +382,6 @@ void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
Constraints, Exprs, Clobbers);
}
void ASTStmtReader::VisitMSLateParsedCompoundStmt(MSLateParsedCompoundStmt *S) {
VisitStmt(S);
SourceLocation LB = ReadSourceLocation(Record, Idx);
SourceLocation RB = ReadSourceLocation(Record, Idx);
std::string StringRep = ReadString(Record, Idx);
unsigned NumToks = Record[Idx++];
// Read the tokens.
SmallVector<Token, 16> Toks;
Toks.reserve(NumToks);
for (unsigned I = 0, E = NumToks; I != E; ++I)
Toks.push_back(ReadToken(Record, Idx));
S->init(Reader.getContext(), LB, RB, Toks, StringRep);
}
void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
// FIXME: Implement coroutine serialization.
llvm_unreachable("unimplemented");
@ -2882,11 +2867,6 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
S = new (Context) MSAsmStmt(Empty);
break;
case STMT_MS_LATE_PARSED_COMPOUND:
S = MSLateParsedCompoundStmt::CreateEmpty(
Context, Record[ASTStmtReader::NumStmtFields]);
break;
case STMT_CAPTURED:
S = CapturedStmt::CreateDeserialized(Context,
Record[ASTStmtReader::NumStmtFields]);

12
clang/lib/Serialization/ASTWriterStmt.cpp
View File

@ -297,18 +297,6 @@ void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {
Code = serialization::STMT_MSASM;
}
void ASTStmtWriter::VisitMSLateParsedCompoundStmt(MSLateParsedCompoundStmt *S) {
VisitStmt(S);
Record.push_back(S->tokens().size());
Record.AddSourceLocation(S->getLocStart());
Record.AddSourceLocation(S->getLocEnd());
Record.AddString(S->getStringRepresentation());
for (auto &Tok : S->tokens())
Writer.AddToken(Tok, Record.getRecordData());
Code = serialization::STMT_MS_LATE_PARSED_COMPOUND;
}
void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
// FIXME: Implement coroutine serialization.
llvm_unreachable("unimplemented");

1
clang/lib/StaticAnalyzer/Core/ExprEngine.cpp
View File

@ -808,7 +808,6 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
case Stmt::SwitchStmtClass:
case Stmt::WhileStmtClass:
case Expr::MSDependentExistsStmtClass:
case Expr::MSLateParsedCompoundStmtClass:
case Stmt::CapturedStmtClass:
case Stmt::OMPParallelDirectiveClass:
case Stmt::OMPSimdDirectiveClass:

1
clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp
View File

@ -556,7 +556,6 @@ struct Base {
template <typename T> struct Template : T {
void member() {
f(); // expected-warning {{found via unqualified lookup into dependent bases}}
T::f();
}
};
void test() {

2
clang/tools/libclang/CIndex.cpp
View File

@ -4632,8 +4632,6 @@ CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
return cxstring::createRef("GCCAsmStmt");
case CXCursor_MSAsmStmt:
return cxstring::createRef("MSAsmStmt");
case CXCursor_MSLateParsedCompoundStmt:
return cxstring::createRef("MSLateParsedCompoundStmt");
case CXCursor_ObjCAtTryStmt:
return cxstring::createRef("ObjCAtTryStmt");
case CXCursor_ObjCAtCatchStmt:

4
clang/tools/libclang/CXCursor.cpp
View File

@ -168,10 +168,6 @@ CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
K = CXCursor_MSAsmStmt;
break;
case Stmt::MSLateParsedCompoundStmtClass:
K = CXCursor_MSLateParsedCompoundStmt;
break;
case Stmt::ObjCAtTryStmtClass:
K = CXCursor_ObjCAtTryStmt;
break;