| //===--- LegacyASTTransformer.cpp - Swift lib/AST -> lib/Syntax -----------===// |
| // |
| // This source file is part of the Swift.org open source project |
| // |
| // Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors |
| // Licensed under Apache License v2.0 with Runtime Library Exception |
| // |
| // See https://swift.org/LICENSE.txt for license information |
| // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "swift/AST/LegacyASTTransformer.h" |
| #include "swift/Syntax/References.h" |
| #include "swift/Syntax/SyntaxFactory.h" |
| #include "swift/Syntax/TokenSyntax.h" |
| #include "swift/Syntax/UnknownSyntax.h" |
| |
| using namespace swift; |
| using namespace swift::syntax; |
| |
| namespace { |
| bool |
| tokenContainsOffset(unsigned Offset, |
| const std::pair<RC<RawTokenSyntax>, |
| AbsolutePosition> &TokAndPos) { |
| auto Start = TokAndPos.second.getOffset(); |
| auto End = Start + TokAndPos.first->getText().size(); |
| return Offset >= Start && Offset < End; |
| } |
| |
| std::vector<RC<RawTokenSyntax>> |
| getRawTokenSyntaxesInRange(SourceRange Range, SourceManager &SourceMgr, |
| unsigned BufferID, |
| const TokenPositionList &Tokens) { |
| auto StartOffset = SourceMgr.getLocOffsetInBuffer(Range.Start, BufferID); |
| auto EndOffset = SourceMgr.getLocOffsetInBuffer(Range.End, BufferID); |
| |
| auto Start = Tokens.begin(); |
| auto End = Tokens.rbegin(); |
| |
| while (Start != Tokens.end()) { |
| if (tokenContainsOffset(StartOffset, *Start)) { |
| break; |
| } |
| ++Start; |
| } |
| |
| while (End != Tokens.rend()) { |
| if (tokenContainsOffset(EndOffset, *End)) { |
| break; |
| } |
| ++End; |
| } |
| |
| assert(Start != Tokens.end()); |
| assert(End.base() != Tokens.end()); |
| assert(Start <= End.base()); |
| |
| std::vector<RC<RawTokenSyntax>> TokensInRange; |
| |
| while (Start < End.base()) { |
| TokensInRange.push_back(Start->first); |
| ++Start; |
| } |
| |
| return TokensInRange; |
| } |
| } // anonymous namespace |
| |
| Optional<Syntax> |
| syntax::transformAST(ASTNode Node, |
| SyntaxASTMap &ASTMap, |
| SourceManager &SourceMgr, |
| const unsigned BufferID, |
| const TokenPositionList &Tokens) { |
| LegacyASTTransformer Transformer { ASTMap, SourceMgr, BufferID, Tokens }; |
| |
| if (Node.is<Expr *>()) { |
| auto E = Node.get<Expr *>(); |
| if (E->isImplicit() || E->getSourceRange().isInvalid()) { |
| return None; |
| } |
| auto Transformed = Transformer.visit(E); |
| ASTMap.recordSyntaxMapping(Transformed, Node); |
| return Syntax { Transformed, Transformed.get() }; |
| } else if (Node.is<Decl *>()) { |
| auto D = Node.get<Decl *>(); |
| if (auto VD = dyn_cast<VarDecl>(D)) { |
| if (VD->getParentPattern()) { |
| return None; |
| } |
| } else if (auto FD = dyn_cast<FuncDecl>(D)) { |
| if (FD->isGetterOrSetter()) { |
| return None; |
| } |
| } |
| if (D->isImplicit() || D->getSourceRange().isInvalid()) { |
| return None; |
| } |
| auto Transformed = Transformer.visit(D); |
| ASTMap.recordSyntaxMapping(Transformed, Node); |
| return Syntax { Transformed, Transformed.get() }; |
| } else if (Node.is<Stmt *>()) { |
| auto S = Node.get<Stmt *>(); |
| if (S->isImplicit() || S->getSourceRange().isInvalid()) { |
| return None; |
| } |
| auto Transformed = Transformer.visit(S); |
| ASTMap.recordSyntaxMapping(Transformed, Node); |
| return Syntax { Transformed, Transformed.get() }; |
| } |
| return None; |
| } |
| |
| SourceLoc LegacyASTTransformer::getStartLocForDecl(const Decl *D) const { |
| return D->getAttrs().isEmpty() |
| ? D->getStartLoc() |
| : D->getAttrs().getStartLoc(); |
| } |
| |
| SourceLoc LegacyASTTransformer::getEndLocForDecl(const Decl *D) const { |
| return D->TrailingSemiLoc.isValid() |
| ? D->TrailingSemiLoc |
| : D->getEndLoc(); |
| } |
| |
| SourceLoc LegacyASTTransformer::getEndLocForStmt(const Stmt *S) const { |
| return S->TrailingSemiLoc.isValid() |
| ? S->TrailingSemiLoc |
| : S->getEndLoc(); |
| } |
| |
| SourceLoc LegacyASTTransformer::getEndLocForExpr(const Expr *E) const { |
| return E->TrailingSemiLoc.isValid() |
| ? E->TrailingSemiLoc |
| : E->getEndLoc(); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::getUnknownSyntax(SourceRange SR, SyntaxKind Kind) { |
| auto ComprisingTokens = getRawTokenSyntaxesInRange(SR, SourceMgr, |
| BufferID, Tokens); |
| RawSyntax::LayoutList Layout; |
| std::copy(ComprisingTokens.begin(), |
| ComprisingTokens.end(), |
| std::back_inserter(Layout)); |
| auto Raw = RawSyntax::make(Kind, Layout, SourcePresence::Present); |
| return SyntaxData::make(Raw); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::getUnknownDecl(Decl *D) { |
| SourceRange SR {getStartLocForDecl(D),getEndLocForDecl(D)}; |
| auto ComprisingTokens = getRawTokenSyntaxesInRange(SR, SourceMgr, |
| BufferID, Tokens); |
| RawSyntax::LayoutList Layout; |
| std::copy(ComprisingTokens.begin(), |
| ComprisingTokens.end(), |
| std::back_inserter(Layout)); |
| auto Raw = RawSyntax::make(SyntaxKind::UnknownDecl, |
| Layout, |
| SourcePresence::Present); |
| return SyntaxData::make(Raw); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::getUnknownStmt(Stmt *S) { |
| SourceRange SR { S->getStartLoc(), getEndLocForStmt(S) }; |
| auto ComprisingTokens = getRawTokenSyntaxesInRange(SR, SourceMgr, |
| BufferID, Tokens); |
| RawSyntax::LayoutList Layout; |
| std::copy(ComprisingTokens.begin(), |
| ComprisingTokens.end(), |
| std::back_inserter(Layout)); |
| auto Raw = RawSyntax::make(SyntaxKind::UnknownStmt, |
| Layout, |
| SourcePresence::Present); |
| return SyntaxData::make(Raw); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::getUnknownExpr(Expr *E) { |
| SourceRange SR { E->getStartLoc(), getEndLocForExpr(E) }; |
| auto ComprisingTokens = getRawTokenSyntaxesInRange(SR, SourceMgr, |
| BufferID, Tokens); |
| RawSyntax::LayoutList Layout; |
| std::copy(ComprisingTokens.begin(), |
| ComprisingTokens.end(), |
| std::back_inserter(Layout)); |
| auto Raw = RawSyntax::make(SyntaxKind::UnknownExpr, |
| Layout, |
| SourcePresence::Present); |
| return SyntaxData::make(Raw); |
| } |
| |
| #pragma mark - Declarations |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitImportDecl(ImportDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitExtensionDecl(ExtensionDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitPatternBindingDecl(PatternBindingDecl *PBD, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(PBD); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitEnumCaseDecl(EnumCaseDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitTopLevelCodeDecl(TopLevelCodeDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| auto body = visitBraceStmt(D->getBody(), Parent, IndexInParent); |
| return SyntaxData::make(RawSyntax::make(SyntaxKind::TopLevelCodeDecl, |
| {body->getRaw()}, |
| SourcePresence::Present)); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitIfConfigDecl(IfConfigDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitPrecedenceGroupDecl( |
| PrecedenceGroupDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitInfixOperatorDecl(InfixOperatorDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitPrefixOperatorDecl(PrefixOperatorDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitPostfixOperatorDecl( |
| PostfixOperatorDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitMissingMemberDecl( |
| MissingMemberDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitGenericTypeParamDecl( |
| GenericTypeParamDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| RC<SyntaxData> |
| LegacyASTTransformer::visitAssociatedTypeDecl(AssociatedTypeDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitTypeAliasDecl(TypeAliasDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitEnumDecl(EnumDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitStructDecl(StructDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| |
| // TODO |
| #if 0 |
| StructDeclSyntaxBuilder StructBuilder; |
| if (D->getStartLoc().isValid()) { |
| auto StructKeyword = findTokenSyntax(tok::kw_struct, "struct", SourceMgr, |
| D->getStartLoc(), BufferID, Tokens); |
| StructBuilder.useStructKeyword(StructKeyword); |
| } |
| |
| if (D->getNameLoc().isValid()) { |
| auto Identifier = findTokenSyntax(tok::identifier, |
| OwnedString(D->getName().str()), |
| SourceMgr, D->getNameLoc(), BufferID, |
| Tokens); |
| StructBuilder.useIdentifier(Identifier); |
| } |
| |
| if (D->getBraces().isValid()) { |
| auto LeftBraceToken = findTokenSyntax(tok::l_brace, "{", SourceMgr, |
| D->getBraces().Start, BufferID, Tokens); |
| StructBuilder.useLeftBrace(LeftBraceToken); |
| auto RightBraceToken = findTokenSyntax(tok::r_brace, "}", SourceMgr, |
| D->getBraces().End, BufferID, Tokens); |
| StructBuilder.useRightBrace(RightBraceToken); |
| } |
| |
| DeclMembersSyntaxBuilder MemberBuilder; |
| for (auto Member : D->getMembers()) { |
| auto TransformedMember = transformAST(Member, ASTMap, |
| SourceMgr, BufferID, Tokens); |
| if (TransformedMember.hasValue()) { |
| if (auto MD = TransformedMember.getValue().getAs<DeclSyntax>()) { |
| MemberBuilder.addMember(MD.getValue()); |
| } else { |
| continue; |
| return getUnknownDecl(D); |
| } |
| } else { |
| continue; |
| return getUnknownDecl(D); |
| } |
| } |
| |
| StructBuilder.useMembers(MemberBuilder.build()); |
| |
| return StructBuilder.build().Root; |
| #endif |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitClassDecl(ClassDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitProtocolDecl(ProtocolDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitModuleDecl(ModuleDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitVarDecl(VarDecl *VD, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(VD); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitParamDecl(ParamDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitSubscriptDecl(SubscriptDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitConstructorDecl(ConstructorDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDestructorDecl(DestructorDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitFuncDecl(FuncDecl *FD, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(FD); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitEnumElementDecl(EnumElementDecl *D, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownDecl(D); |
| } |
| |
| #pragma mark - Statements |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitBraceStmt(BraceStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| auto LeftBrace = S->getLBraceLoc().isValid() |
| ? findTokenSyntax(tok::l_brace, "{", SourceMgr, S->getLBraceLoc(), |
| BufferID, Tokens) |
| : TokenSyntax::missingToken(tok::l_brace, "{"); |
| |
| /// Because this syntax comes from an ASTNode, we need to handle Decl/Expr |
| /// and convert them into implicit DeclStmtSyntax and ExprStmtSyntaxes. |
| auto getStmtSyntax = [](Syntax Node) -> StmtSyntax { |
| if (Node.isDecl()) |
| return SyntaxFactory::makeDeclarationStmt(Node.castTo<DeclSyntax>(), |
| None); |
| if (Node.isExpr()) |
| return SyntaxFactory::makeExpressionStmt(Node.castTo<ExprSyntax>(), |
| None); |
| return Node.castTo<StmtSyntax>(); |
| }; |
| |
| std::vector<StmtSyntax> Stmts; |
| for (auto Node : S->getElements()) { |
| auto Transformed = transformAST(Node, ASTMap, SourceMgr, BufferID, Tokens); |
| if (Transformed.hasValue()) { |
| Stmts.push_back(getStmtSyntax(*Transformed)); |
| } |
| } |
| |
| auto RightBrace = S->getLBraceLoc().isValid() |
| ? findTokenSyntax(tok::r_brace, "}", SourceMgr, S->getLBraceLoc(), |
| BufferID, Tokens) |
| : TokenSyntax::missingToken(tok::r_brace, "}"); |
| |
| auto StmtList = SyntaxFactory::makeStmtList(Stmts); |
| |
| return SyntaxFactory::makeCodeBlock(LeftBrace, StmtList, RightBrace).Root; |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitReturnStmt(ReturnStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| auto ReturnKW = findTokenSyntax(tok::kw_return, "return", SourceMgr, |
| S->getReturnLoc(), BufferID, Tokens); |
| auto Semicolon = findTokenSyntax(tok::semi, ";", SourceMgr, |
| S->getEndLoc(), BufferID, Tokens); |
| auto Result = transformAST(S->getResult(), ASTMap, SourceMgr, BufferID, |
| Tokens); |
| |
| if (!Result.hasValue()) { |
| return getUnknownStmt(S); |
| } |
| |
| return SyntaxFactory::makeReturnStmt(ReturnKW, |
| Result.getValue().castTo<ExprSyntax>(), Semicolon).Root; |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDeferStmt(DeferStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitIfStmt(IfStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitGuardStmt(GuardStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitWhileStmt(WhileStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDoStmt(DoStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDoCatchStmt(DoCatchStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitRepeatWhileStmt(RepeatWhileStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitForEachStmt(ForEachStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitSwitchStmt(SwitchStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitCaseStmt(CaseStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitCatchStmt(CatchStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitBreakStmt(BreakStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitContinueStmt(ContinueStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitFallthroughStmt(FallthroughStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| if (S->getLoc().isInvalid()) { |
| return SyntaxFactory::makeBlankFallthroughStmt().Root; |
| } |
| |
| auto FallthroughToken = findTokenSyntax(tok::kw_fallthrough, "fallthrough", |
| SourceMgr, S->getLoc(), |
| BufferID, Tokens); |
| auto Semicolon = SyntaxFactory::makeToken(tok::semi, ";", SourcePresence::Missing, |
| {}, {}); |
| return SyntaxFactory::makeFallthroughStmt(FallthroughToken, Semicolon).Root; |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitFailStmt(FailStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitThrowStmt(ThrowStmt *S, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownStmt(S); |
| } |
| |
| #pragma mark - Expressions |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitErrorExpr(ErrorExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitNilLiteralExpr(NilLiteralExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitIntegerLiteralExpr(IntegerLiteralExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| auto Sign = E->getMinusLoc().isValid() |
| ? findTokenSyntax(tok::oper_prefix, OwnedString(), |
| SourceMgr, E->getMinusLoc(), |
| BufferID, Tokens) |
| : TokenSyntax::missingToken(tok::oper_prefix, ""); |
| auto Digits = findTokenSyntax(tok::integer_literal, OwnedString(), |
| SourceMgr, E->getDigitsLoc(), |
| BufferID, Tokens); |
| return SyntaxFactory::makeIntegerLiteralExpr(Sign, Digits).Root; |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitFloatLiteralExpr(FloatLiteralExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitBooleanLiteralExpr(BooleanLiteralExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitStringLiteralExpr(StringLiteralExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitInterpolatedStringLiteralExpr( |
| InterpolatedStringLiteralExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitObjectLiteralExpr(ObjectLiteralExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitMagicIdentifierLiteralExpr( |
| MagicIdentifierLiteralExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDiscardAssignmentExpr( |
| DiscardAssignmentExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDeclRefExpr(DeclRefExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitSuperRefExpr(SuperRefExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitTypeExpr(TypeExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitOtherConstructorDeclRefExpr( |
| OtherConstructorDeclRefExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitDotSyntaxBaseIgnoredExpr( |
| DotSyntaxBaseIgnoredExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitOverloadedDeclRefExpr( |
| OverloadedDeclRefExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitUnresolvedDeclRefExpr( |
| UnresolvedDeclRefExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitMemberRefExpr(MemberRefExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDynamicMemberRefExpr( |
| DynamicMemberRefExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDynamicSubscriptExpr( |
| DynamicSubscriptExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitUnresolvedSpecializeExpr( |
| UnresolvedSpecializeExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitUnresolvedMemberExpr( |
| UnresolvedMemberExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitUnresolvedDotExpr(UnresolvedDotExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitSequenceExpr(SequenceExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitParenExpr(ParenExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDotSelfExpr(DotSelfExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitTryExpr(TryExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitForceTryExpr(ForceTryExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitOptionalTryExpr(OptionalTryExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitTupleExpr(TupleExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitArrayExpr(ArrayExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDictionaryExpr(DictionaryExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitSubscriptExpr(SubscriptExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitTupleElementExpr(TupleElementExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitCaptureListExpr(CaptureListExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitClosureExpr(ClosureExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitAutoClosureExpr(AutoClosureExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitInOutExpr(InOutExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDynamicTypeExpr(DynamicTypeExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitRebindSelfInConstructorExpr( |
| RebindSelfInConstructorExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitOpaqueValueExpr(OpaqueValueExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitBindOptionalExpr(BindOptionalExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitOptionalEvaluationExpr( |
| OptionalEvaluationExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitForceValueExpr(ForceValueExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitOpenExistentialExpr( |
| OpenExistentialExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitMakeTemporarilyEscapableExpr( |
| MakeTemporarilyEscapableExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitCallExpr(CallExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitPrefixUnaryExpr(PrefixUnaryExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitPostfixUnaryExpr(PostfixUnaryExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitBinaryExpr(BinaryExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDotSyntaxCallExpr(DotSyntaxCallExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitConstructorRefCallExpr( |
| ConstructorRefCallExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitLoadExpr(LoadExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitTupleShuffleExpr(TupleShuffleExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitUnresolvedTypeConversionExpr( |
| UnresolvedTypeConversionExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitFunctionConversionExpr( |
| FunctionConversionExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitCovariantFunctionConversionExpr( |
| CovariantFunctionConversionExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitCovariantReturnConversionExpr( |
| CovariantReturnConversionExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitMetatypeConversionExpr( |
| MetatypeConversionExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitCollectionUpcastConversionExpr( |
| CollectionUpcastConversionExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitErasureExpr(ErasureExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitAnyHashableErasureExpr( |
| AnyHashableErasureExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitDerivedToBaseExpr(DerivedToBaseExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitArchetypeToSuperExpr( |
| ArchetypeToSuperExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitInjectIntoOptionalExpr( |
| InjectIntoOptionalExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitConditionalBridgeFromObjCExpr( |
| ConditionalBridgeFromObjCExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitBridgeFromObjCExpr( |
| BridgeFromObjCExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitBridgeToObjCExpr( |
| BridgeToObjCExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitClassMetatypeToObjectExpr( |
| ClassMetatypeToObjectExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitExistentialMetatypeToObjectExpr( |
| ExistentialMetatypeToObjectExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitProtocolMetatypeToObjectExpr( |
| ProtocolMetatypeToObjectExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitInOutToPointerExpr(InOutToPointerExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitArrayToPointerExpr(ArrayToPointerExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitStringToPointerExpr( |
| StringToPointerExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitPointerToPointerExpr( |
| PointerToPointerExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitForeignObjectConversionExpr( |
| ForeignObjectConversionExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitUnevaluatedInstanceExpr( |
| UnevaluatedInstanceExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitForcedCheckedCastExpr( |
| ForcedCheckedCastExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitConditionalCheckedCastExpr( |
| ConditionalCheckedCastExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> LegacyASTTransformer::visitKeyPathApplicationExpr( |
| KeyPathApplicationExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitIsExpr(IsExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitCoerceExpr(CoerceExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitArrowExpr(ArrowExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitIfExpr(IfExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitEnumIsCaseExpr(EnumIsCaseExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitAssignExpr(AssignExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitCodeCompletionExpr(CodeCompletionExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitUnresolvedPatternExpr( |
| UnresolvedPatternExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitEditorPlaceholderExpr( |
| EditorPlaceholderExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitObjCSelectorExpr(ObjCSelectorExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitKeyPathExpr(KeyPathExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| RC<SyntaxData> |
| LegacyASTTransformer::visitKeyPathDotExpr(KeyPathDotExpr *E, |
| const SyntaxData *Parent, |
| const CursorIndex IndexInParent) { |
| return getUnknownExpr(E); |
| } |
| |
| TokenSyntax |
| syntax::findTokenSyntax(tok ExpectedKind, |
| OwnedString ExpectedText, |
| SourceManager &SourceMgr, |
| SourceLoc Loc, |
| unsigned BufferID, |
| const TokenPositionList &Tokens) { |
| auto Offset = SourceMgr.getLocOffsetInBuffer(Loc, BufferID); |
| |
| size_t Start = 0; |
| size_t End = Tokens.size() - 1; |
| |
| while (Start <= End) { |
| auto Mid = (Start + End) / 2; |
| auto TokAndPos = Tokens[Mid]; |
| auto Tok = TokAndPos.first; |
| auto Pos = TokAndPos.second; |
| |
| auto TokStart = Pos.getOffset(); |
| |
| if (Offset == TokStart) { |
| if (Tok->getTokenKind() == ExpectedKind && |
| (ExpectedText.empty() || Tok->getText() == ExpectedText.str())) { |
| return make<TokenSyntax>(Tok); |
| } else { |
| return TokenSyntax::missingToken(ExpectedKind, ExpectedText); |
| } |
| } |
| |
| if (TokStart < Offset) { |
| Start = Mid + 1; |
| } else { |
| End = Mid - 1; |
| } |
| } |
| |
| return TokenSyntax::missingToken(ExpectedKind, ExpectedText); |
| } |