Revert "[llvm] add support for mustache templating language (#105893)" #130873
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-llvm-support Author: None (PeterChou1) ChangesThis patch caused certain GCC buildbots to failed Patch is 69.42 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/130873.diff 5 Files Affected:
diff --git a/llvm/include/llvm/Support/Mustache.h b/llvm/include/llvm/Support/Mustache.h
deleted file mode 100644
index 41173b96d1a9a..0000000000000
--- a/llvm/include/llvm/Support/Mustache.h
+++ /dev/null
@@ -1,127 +0,0 @@
-//===--- Mustache.h ---------------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Implementation of the Mustache templating language supports version 1.4.2
-// currently relies on llvm::json::Value for data input.
-// See the Mustache spec for more information
-// (https://mustache.github.io/mustache.5.html).
-//
-// Current Features Supported:
-// - Variables
-// - Sections
-// - Inverted Sections
-// - Partials
-// - Comments
-// - Lambdas
-// - Unescaped Variables
-//
-// Features Not Supported:
-// - Set Delimiter
-// - Blocks
-// - Parents
-// - Dynamic Names
-//
-// The Template class is a container class that outputs the Mustache template
-// string and is the main class for users. It stores all the lambdas and the
-// ASTNode Tree. When the Template is instantiated it tokenizes the Template
-// String and creates a vector of Tokens. Then it calls a basic recursive
-// descent parser to construct the ASTNode Tree. The ASTNodes are all stored
-// in an arena allocator which is freed once the template class goes out of
-// scope.
-//
-// Usage:
-// \code
-// // Creating a simple template and rendering it
-// auto Template = Template("Hello, {{name}}!");
-// Value Data = {{"name", "World"}};
-// std::string Out;
-// raw_string_ostream OS(Out);
-// T.render(Data, OS);
-// // Out == "Hello, World!"
-//
-// // Creating a template with a partial and rendering it
-// auto Template = Template("{{>partial}}");
-// Template.registerPartial("partial", "Hello, {{name}}!");
-// Value Data = {{"name", "World"}};
-// std::string Out;
-// raw_string_ostream OS(Out);
-// T.render(Data, OS);
-// // Out == "Hello, World!"
-//
-// // Creating a template with a lambda and rendering it
-// Value D = Object{};
-// auto T = Template("Hello, {{lambda}}!");
-// Lambda L = []() -> llvm::json::Value { return "World"; };
-// T.registerLambda("lambda", L);
-// std::string Out;
-// raw_string_ostream OS(Out);
-// T.render(D, OS);
-// // Out == "Hello, World!"
-// \endcode
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_MUSTACHE
-#define LLVM_SUPPORT_MUSTACHE
-
-#include "Error.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/Support/Allocator.h"
-#include "llvm/Support/JSON.h"
-#include "llvm/Support/StringSaver.h"
-#include <functional>
-#include <vector>
-
-namespace llvm::mustache {
-
-using Lambda = std::function<llvm::json::Value()>;
-using SectionLambda = std::function<llvm::json::Value(std::string)>;
-
-class ASTNode;
-
-// A Template represents the container for the AST and the partials
-// and Lambdas that are registered with it.
-class Template {
-public:
- Template(StringRef TemplateStr);
-
- Template(const Template &) = delete;
-
- Template &operator=(const Template &) = delete;
-
- Template(Template &&Other) noexcept;
-
- Template &operator=(Template &&Other) noexcept;
-
- void render(const llvm::json::Value &Data, llvm::raw_ostream &OS);
-
- void registerPartial(std::string Name, std::string Partial);
-
- void registerLambda(std::string Name, Lambda Lambda);
-
- void registerLambda(std::string Name, SectionLambda Lambda);
-
- // By default the Mustache Spec Specifies that HTML special characters
- // should be escaped. This function allows the user to specify which
- // characters should be escaped.
- void overrideEscapeCharacters(DenseMap<char, std::string> Escapes);
-
-private:
- StringMap<ASTNode *> Partials;
- StringMap<Lambda> Lambdas;
- StringMap<SectionLambda> SectionLambdas;
- DenseMap<char, std::string> Escapes;
- // The allocator for the ASTNode Tree
- llvm::BumpPtrAllocator AstAllocator;
- // Allocator for each render call resets after each render
- llvm::BumpPtrAllocator RenderAllocator;
- ASTNode *Tree;
-};
-} // namespace llvm::mustache
-
-#endif // LLVM_SUPPORT_MUSTACHE
diff --git a/llvm/lib/Support/CMakeLists.txt b/llvm/lib/Support/CMakeLists.txt
index 2754c97fce6c1..49a26a618de83 100644
--- a/llvm/lib/Support/CMakeLists.txt
+++ b/llvm/lib/Support/CMakeLists.txt
@@ -220,7 +220,6 @@ add_llvm_component_library(LLVMSupport
MD5.cpp
MSP430Attributes.cpp
MSP430AttributeParser.cpp
- Mustache.cpp
NativeFormatting.cpp
OptimizedStructLayout.cpp
Optional.cpp
diff --git a/llvm/lib/Support/Mustache.cpp b/llvm/lib/Support/Mustache.cpp
deleted file mode 100644
index 2735bf2ca3b9b..0000000000000
--- a/llvm/lib/Support/Mustache.cpp
+++ /dev/null
@@ -1,793 +0,0 @@
-//===-- Mustache.cpp ------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-#include "llvm/Support/Mustache.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/raw_ostream.h"
-#include <sstream>
-
-using namespace llvm;
-using namespace llvm::mustache;
-
-namespace {
-
-using Accessor = SmallVector<std::string>;
-
-static bool isFalsey(const json::Value &V) {
- return V.getAsNull() || (V.getAsBoolean() && !V.getAsBoolean().value()) ||
- (V.getAsArray() && V.getAsArray()->empty());
-}
-
-static Accessor splitMustacheString(StringRef Str) {
- // We split the mustache string into an accessor.
- // For example:
- // "a.b.c" would be split into {"a", "b", "c"}
- // We make an exception for a single dot which
- // refers to the current context.
- Accessor Tokens;
- if (Str == ".") {
- Tokens.emplace_back(Str);
- return Tokens;
- }
- while (!Str.empty()) {
- StringRef Part;
- std::tie(Part, Str) = Str.split(".");
- Tokens.emplace_back(Part.trim());
- }
- return Tokens;
-}
-} // namespace
-
-namespace llvm::mustache {
-
-class Token {
-public:
- enum class Type {
- Text,
- Variable,
- Partial,
- SectionOpen,
- SectionClose,
- InvertSectionOpen,
- UnescapeVariable,
- Comment,
- };
-
- Token(std::string Str)
- : TokenType(Type::Text), RawBody(std::move(Str)), TokenBody(RawBody),
- AccessorValue({}), Indentation(0) {};
-
- Token(std::string RawBody, std::string TokenBody, char Identifier)
- : RawBody(std::move(RawBody)), TokenBody(std::move(TokenBody)),
- Indentation(0) {
- TokenType = getTokenType(Identifier);
- if (TokenType == Type::Comment)
- return;
- StringRef AccessorStr(this->TokenBody);
- if (TokenType != Type::Variable)
- AccessorStr = AccessorStr.substr(1);
- AccessorValue = splitMustacheString(StringRef(AccessorStr).trim());
- }
-
- Accessor getAccessor() const { return AccessorValue; }
-
- Type getType() const { return TokenType; }
-
- void setIndentation(size_t NewIndentation) { Indentation = NewIndentation; }
-
- size_t getIndentation() const { return Indentation; }
-
- static Type getTokenType(char Identifier) {
- switch (Identifier) {
- case '#':
- return Type::SectionOpen;
- case '/':
- return Type::SectionClose;
- case '^':
- return Type::InvertSectionOpen;
- case '!':
- return Type::Comment;
- case '>':
- return Type::Partial;
- case '&':
- return Type::UnescapeVariable;
- default:
- return Type::Variable;
- }
- }
-
- Type TokenType;
- // RawBody is the original string that was tokenized.
- std::string RawBody;
- // TokenBody is the original string with the identifier removed.
- std::string TokenBody;
- Accessor AccessorValue;
- size_t Indentation;
-};
-
-class ASTNode {
-public:
- enum Type {
- Root,
- Text,
- Partial,
- Variable,
- UnescapeVariable,
- Section,
- InvertSection,
- };
-
- ASTNode(llvm::BumpPtrAllocator &Alloc, llvm::StringMap<ASTNode *> &Partials,
- llvm::StringMap<Lambda> &Lambdas,
- llvm::StringMap<SectionLambda> &SectionLambdas,
- llvm::DenseMap<char, std::string> &Escapes)
- : Allocator(Alloc), Partials(Partials), Lambdas(Lambdas),
- SectionLambdas(SectionLambdas), Escapes(Escapes), Ty(Type::Root),
- Parent(nullptr), ParentContext(nullptr) {}
-
- ASTNode(std::string Body, ASTNode *Parent, llvm::BumpPtrAllocator &Alloc,
- llvm::StringMap<ASTNode *> &Partials,
- llvm::StringMap<Lambda> &Lambdas,
- llvm::StringMap<SectionLambda> &SectionLambdas,
- llvm::DenseMap<char, std::string> &Escapes)
- : Allocator(Alloc), Partials(Partials), Lambdas(Lambdas),
- SectionLambdas(SectionLambdas), Escapes(Escapes), Ty(Type::Text),
- Body(std::move(Body)), Parent(Parent), ParentContext(nullptr) {}
-
- // Constructor for Section/InvertSection/Variable/UnescapeVariable Nodes
- ASTNode(Type Ty, Accessor Accessor, ASTNode *Parent,
- llvm::BumpPtrAllocator &Alloc, llvm::StringMap<ASTNode *> &Partials,
- llvm::StringMap<Lambda> &Lambdas,
- llvm::StringMap<SectionLambda> &SectionLambdas,
- llvm::DenseMap<char, std::string> &Escapes)
- : Allocator(Alloc), Partials(Partials), Lambdas(Lambdas),
- SectionLambdas(SectionLambdas), Escapes(Escapes), Ty(Ty),
- Parent(Parent), AccessorValue(std::move(Accessor)),
- ParentContext(nullptr) {}
-
- void addChild(ASTNode *Child) { Children.emplace_back(Child); };
-
- void setRawBody(std::string NewBody) { RawBody = std::move(NewBody); };
-
- void setIndentation(size_t NewIndentation) { Indentation = NewIndentation; };
-
- void render(const llvm::json::Value &Data, llvm::raw_ostream &OS);
-
-private:
- void renderLambdas(const llvm::json::Value &Contexts, llvm::raw_ostream &OS,
- Lambda &L);
-
- void renderSectionLambdas(const llvm::json::Value &Contexts,
- llvm::raw_ostream &OS, SectionLambda &L);
-
- void renderPartial(const llvm::json::Value &Contexts, llvm::raw_ostream &OS,
- ASTNode *Partial);
-
- void renderChild(const llvm::json::Value &Context, llvm::raw_ostream &OS);
-
- const llvm::json::Value *findContext();
-
- llvm::BumpPtrAllocator &Allocator;
- StringMap<ASTNode *> &Partials;
- StringMap<Lambda> &Lambdas;
- StringMap<SectionLambda> &SectionLambdas;
- DenseMap<char, std::string> &Escapes;
- Type Ty;
- size_t Indentation = 0;
- std::string RawBody;
- std::string Body;
- ASTNode *Parent;
- // TODO: switch implementation to SmallVector<T>
- std::vector<ASTNode *> Children;
- const Accessor AccessorValue;
- const llvm::json::Value *ParentContext;
-};
-
-// A wrapper for arena allocator for ASTNodes
-ASTNode *createRootNode(void *Node, llvm::BumpPtrAllocator &Alloc,
- llvm::StringMap<ASTNode *> &Partials,
- llvm::StringMap<Lambda> &Lambdas,
- llvm::StringMap<SectionLambda> &SectionLambdas,
- llvm::DenseMap<char, std::string> &Escapes) {
- return new (Node) ASTNode(Alloc, Partials, Lambdas, SectionLambdas, Escapes);
-}
-
-ASTNode *createNode(void *Node, ASTNode::Type T, Accessor A, ASTNode *Parent,
- llvm::BumpPtrAllocator &Alloc,
- llvm::StringMap<ASTNode *> &Partials,
- llvm::StringMap<Lambda> &Lambdas,
- llvm::StringMap<SectionLambda> &SectionLambdas,
- llvm::DenseMap<char, std::string> &Escapes) {
- return new (Node) ASTNode(T, std::move(A), Parent, Alloc, Partials, Lambdas,
- SectionLambdas, Escapes);
-}
-
-ASTNode *createTextNode(void *Node, std::string Body, ASTNode *Parent,
- llvm::BumpPtrAllocator &Alloc,
- llvm::StringMap<ASTNode *> &Partials,
- llvm::StringMap<Lambda> &Lambdas,
- llvm::StringMap<SectionLambda> &SectionLambdas,
- llvm::DenseMap<char, std::string> &Escapes) {
- return new (Node) ASTNode(std::move(Body), Parent, Alloc, Partials, Lambdas,
- SectionLambdas, Escapes);
-}
-
-// Function to check if there is meaningful text behind.
-// We determine if a token has meaningful text behind
-// if the right of previous token contains anything that is
-// not a newline.
-// For example:
-// "Stuff {{#Section}}" (returns true)
-// vs
-// "{{#Section}} \n" (returns false)
-// We make an exception for when previous token is empty
-// and the current token is the second token.
-// For example:
-// "{{#Section}}"
-bool hasTextBehind(size_t Idx, const ArrayRef<Token> &Tokens) {
- if (Idx == 0)
- return true;
-
- size_t PrevIdx = Idx - 1;
- if (Tokens[PrevIdx].getType() != Token::Type::Text)
- return true;
-
- const Token &PrevToken = Tokens[PrevIdx];
- StringRef TokenBody = StringRef(PrevToken.RawBody).rtrim(" \r\t\v");
- return !TokenBody.ends_with("\n") && !(TokenBody.empty() && Idx == 1);
-}
-
-// Function to check if there's no meaningful text ahead.
-// We determine if a token has text ahead if the left of previous
-// token does not start with a newline.
-bool hasTextAhead(size_t Idx, const ArrayRef<Token> &Tokens) {
- if (Idx >= Tokens.size() - 1)
- return true;
-
- size_t NextIdx = Idx + 1;
- if (Tokens[NextIdx].getType() != Token::Type::Text)
- return true;
-
- const Token &NextToken = Tokens[NextIdx];
- StringRef TokenBody = StringRef(NextToken.RawBody).ltrim(" ");
- return !TokenBody.starts_with("\r\n") && !TokenBody.starts_with("\n");
-}
-
-bool requiresCleanUp(Token::Type T) {
- // We must clean up all the tokens that could contain child nodes.
- return T == Token::Type::SectionOpen || T == Token::Type::InvertSectionOpen ||
- T == Token::Type::SectionClose || T == Token::Type::Comment ||
- T == Token::Type::Partial;
-}
-
-// Adjust next token body if there is no text ahead.
-// For example:
-// The template string
-// "{{! Comment }} \nLine 2"
-// would be considered as no text ahead and should be rendered as
-// " Line 2"
-void stripTokenAhead(SmallVectorImpl<Token> &Tokens, size_t Idx) {
- Token &NextToken = Tokens[Idx + 1];
- StringRef NextTokenBody = NextToken.TokenBody;
- // Cut off the leading newline which could be \n or \r\n.
- if (NextTokenBody.starts_with("\r\n"))
- NextToken.TokenBody = NextTokenBody.substr(2).str();
- else if (NextTokenBody.starts_with("\n"))
- NextToken.TokenBody = NextTokenBody.substr(1).str();
-}
-
-// Adjust previous token body if there no text behind.
-// For example:
-// The template string
-// " \t{{#section}}A{{/section}}"
-// would be considered as having no text ahead and would be render as
-// "A"
-// The exception for this is partial tag which requires us to
-// keep track of the indentation once it's rendered.
-void stripTokenBefore(SmallVectorImpl<Token> &Tokens, size_t Idx,
- Token &CurrentToken, Token::Type CurrentType) {
- Token &PrevToken = Tokens[Idx - 1];
- StringRef PrevTokenBody = PrevToken.TokenBody;
- StringRef Unindented = PrevTokenBody.rtrim(" \r\t\v");
- size_t Indentation = PrevTokenBody.size() - Unindented.size();
- if (CurrentType != Token::Type::Partial)
- PrevToken.TokenBody = Unindented.str();
- CurrentToken.setIndentation(Indentation);
-}
-
-// Simple tokenizer that splits the template into tokens.
-// The mustache spec allows {{{ }}} to unescape variables,
-// but we don't support that here. An unescape variable
-// is represented only by {{& variable}}.
-SmallVector<Token> tokenize(StringRef Template) {
- SmallVector<Token> Tokens;
- StringLiteral Open("{{");
- StringLiteral Close("}}");
- size_t Start = 0;
- size_t DelimiterStart = Template.find(Open);
- if (DelimiterStart == StringRef::npos) {
- Tokens.emplace_back(Template.str());
- return Tokens;
- }
- while (DelimiterStart != StringRef::npos) {
- if (DelimiterStart != Start)
- Tokens.emplace_back(Template.substr(Start, DelimiterStart - Start).str());
- size_t DelimiterEnd = Template.find(Close, DelimiterStart);
- if (DelimiterEnd == StringRef::npos)
- break;
-
- // Extract the Interpolated variable without delimiters.
- size_t InterpolatedStart = DelimiterStart + Open.size();
- size_t InterpolatedEnd = DelimiterEnd - DelimiterStart - Close.size();
- std::string Interpolated =
- Template.substr(InterpolatedStart, InterpolatedEnd).str();
- std::string RawBody = Open.str() + Interpolated + Close.str();
- Tokens.emplace_back(RawBody, Interpolated, Interpolated[0]);
- Start = DelimiterEnd + Close.size();
- DelimiterStart = Template.find(Open, Start);
- }
-
- if (Start < Template.size())
- Tokens.emplace_back(Template.substr(Start).str());
-
- // Fix up white spaces for:
- // - open sections
- // - inverted sections
- // - close sections
- // - comments
- //
- // This loop attempts to find standalone tokens and tries to trim out
- // the surrounding whitespace.
- // For example:
- // if you have the template string
- // {{#section}} \n Example \n{{/section}}
- // The output should would be
- // For example:
- // \n Example \n
- size_t LastIdx = Tokens.size() - 1;
- for (size_t Idx = 0, End = Tokens.size(); Idx < End; ++Idx) {
- Token &CurrentToken = Tokens[Idx];
- Token::Type CurrentType = CurrentToken.getType();
- // Check if token type requires cleanup.
- bool RequiresCleanUp = requiresCleanUp(CurrentType);
-
- if (!RequiresCleanUp)
- continue;
-
- // We adjust the token body if there's no text behind or ahead.
- // A token is considered to have no text ahead if the right of the previous
- // token is a newline followed by spaces.
- // A token is considered to have no text behind if the left of the next
- // token is spaces followed by a newline.
- // eg.
- // "Line 1\n {{#section}} \n Line 2 \n {{/section}} \n Line 3"
- bool HasTextBehind = hasTextBehind(Idx, Tokens);
- bool HasTextAhead = hasTextAhead(Idx, Tokens);
-
- if ((!HasTextAhead && !HasTextBehind) || (!HasTextAhead && Idx == 0))
- stripTokenAhead(Tokens, Idx);
-
- if ((!HasTextBehind && !HasTextAhead) || (!HasTextBehind && Idx == LastIdx))
- stripTokenBefore(Tokens, Idx, CurrentToken, CurrentType);
- }
- return Tokens;
-}
-
-// Custom stream to escape strings.
-class EscapeStringStream : public raw_ostream {
-public:
- explicit EscapeStringStream(llvm::raw_ostream &WrappedStream,
- DenseMap<char, std::string> &Escape)
- : Escape(Escape), WrappedStream(WrappedStream) {
- SetUnbuffered();
- }
-
-protected:
- void write_impl(const char *Ptr, size_t Size) override {
- llvm::StringRef Data(Ptr, Size);
- for (char C : Data) {
- auto It = Escape.find(C);
- if (It != Escape.end())
- WrappedStream << It->getSecond();
- else
- WrappedStream << C;
- }
- }
-
- uint64_t current_pos() const override { return WrappedStream.tell(); }
-
-private:
- DenseMap<char, std::string> &Escape;
- llvm::raw_ostream &WrappedStream;
-};
-
-// Custom stream to add indentation used to for rendering partials.
-class AddIndentationStringStream : public raw_ostream {
-public:
- explicit AddIndentationStringStream(llvm::raw_ostream &WrappedStream,
- size_t Indentation)
- : Indentation(Indentation), WrappedStream(WrappedStream) {
- SetUnbuffered();
- }
-
-protected:
- void write_impl(const char *Ptr, size_t Size) override {
- llvm::StringRef Data(Ptr, Size);
- SmallString<0> Indent;
- Indent.resize(Indentation, ' ');
- for (char C : Data) {
- WrappedStream << C;
- if (C == '\n')
- WrappedStream << Indent;
- }
- }
-
- uint64_t current_pos() const override { return WrappedStream.tell(); }
-
-private:
- size_t Indentation;
- llvm::raw_ostream &WrappedStream;
-};
-
-class Parser {
-public:
- Parser(...
[truncated]
|
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/190/builds/16176 Here is the relevant piece of the build log for the reference |
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/146/builds/2474 Here is the relevant piece of the build log for the reference |
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/38/builds/2678 Here is the relevant piece of the build log for the reference |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This patch caused certain GCC buildbots to failed
errors: https://lab.llvm.org/buildbot/#/builders/66/builds/11049