RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/AtomicChange_8cpp_source.html below:

clang: lib/Tooling/Refactoring/AtomicChange.cpp Source File

11#include "llvm/Support/YAMLTraits.h" 21struct

NormalizedAtomicChange {

22

NormalizedAtomicChange() =

default

;

24

NormalizedAtomicChange(

const

llvm::yaml::IO &) {}

28

NormalizedAtomicChange(

const

llvm::yaml::IO &,

30

: Key(

.getKey()), FilePath(

.getFilePath()),

Error

(

.getError()),

31

InsertedHeaders(

.getInsertedHeaders()),

32

RemovedHeaders(

.getRemovedHeaders()),

33

Replaces(

.getReplacements().begin(),

.getReplacements().end()) {}

37

llvm_unreachable(

"Do not convert YAML to AtomicChange directly with '>>'. " 38 "Use AtomicChange::convertFromYAML instead."

);

43

std::vector<std::string> InsertedHeaders;

44

std::vector<std::string> RemovedHeaders;

45

std::vector<clang::tooling::Replacement> Replaces;

54template

struct

MappingTraits<NormalizedAtomicChange> {

55 static void mapping

(IO &Io, NormalizedAtomicChange &Doc) {

56

Io.mapRequired(

"Key"

, Doc.Key);

57

Io.mapRequired(

"FilePath"

, Doc.FilePath);

58

Io.mapRequired(

"Error"

, Doc.Error);

59

Io.mapRequired(

"InsertedHeaders"

, Doc.InsertedHeaders);

60

Io.mapRequired(

"RemovedHeaders"

, Doc.RemovedHeaders);

61

Io.mapRequired(

"Replacements"

, Doc.Replaces);

67template

struct

MappingTraits<

clang

::tooling::AtomicChange> {

69

MappingNormalization<NormalizedAtomicChange, clang::tooling::AtomicChange>

71

Io.mapRequired(

"Key"

, Keys->Key);

72

Io.mapRequired(

"FilePath"

, Keys->FilePath);

73

Io.mapRequired(

"Error"

, Keys->Error);

74

Io.mapRequired(

"InsertedHeaders"

, Keys->InsertedHeaders);

75

Io.mapRequired(

"RemovedHeaders"

, Keys->RemovedHeaders);

76

Io.mapRequired(

"Replacements"

, Keys->Replaces);

89bool

violatesColumnLimit(llvm::StringRef Code,

unsigned

ColumnLimit,

90 unsigned

Start,

unsigned

End) {

91 auto

StartPos = Code.rfind(

'\n'

, Start);

92

StartPos = (StartPos == llvm::StringRef::npos) ? 0 : StartPos + 1;

94 auto

EndPos = Code.find(

"\n"

, End);

95 if

(EndPos == llvm::StringRef::npos)

99

Code.substr(StartPos, EndPos - StartPos).split(Lines,

'\n'

);

100 for

(llvm::StringRef

Line

: Lines)

101 if

(

Line

.size() > ColumnLimit)

107

getRangesForFormatting(llvm::StringRef Code,

unsigned

ColumnLimit,

113

std::vector<clang::tooling::Range> Ranges;

119 int

Start = R.getOffset() + Offset;

120 int

End = Start + R.getReplacementText().size();

121 if

(!R.getReplacementText().empty() &&

122

R.getReplacementText().back() ==

'\n'

&& R.getLength() == 0 &&

123

R.getOffset() > 0 && R.getOffset() <= Code.size() &&

124

Code[R.getOffset() - 1] ==

'\n'

)

128

Offset += R.getReplacementText().size() - R.getLength();

131

violatesColumnLimit(Code, ColumnLimit, Start, End))

132

Ranges.emplace_back(Start, End - Start);

138 return

llvm::make_error<llvm::StringError>(Message,

139

llvm::inconvertibleErrorCode());

144

createReplacementsForHeaders(llvm::StringRef FilePath, llvm::StringRef Code,

146 const

format::FormatStyle &Style) {

149

Replacements HeaderReplacements;

150 for

(

const auto

&Change : Changes) {

151 for

(llvm::StringRef Header : Change.getInsertedHeaders()) {

152

std::string EscapedHeader =

153

Header.starts_with(

"<"

) || Header.starts_with(

"\""

)

155

: (

"\""

+ Header +

"\""

).str();

156

std::string ReplacementText =

"#include "

+ EscapedHeader;

159

llvm::Error Err = HeaderReplacements.add(

160

tooling::Replacement(FilePath,

UINT_MAX

, 0, ReplacementText));

162 return

std::move(Err);

164 for

(

const

std::string &Header : Change.getRemovedHeaders()) {

168

HeaderReplacements.add(Replacement(FilePath,

UINT_MAX

, 1, Header));

170 return

std::move(Err);

183

combineReplacementsInChanges(llvm::StringRef FilePath,

185

Replacements Replaces;

186 for

(

const auto

&Change : Changes)

187 for

(

const auto

&R : Change.getReplacements())

188 if

(

auto

Err = Replaces.add(Replacement(

189

FilePath, R.getOffset(), R.getLength(), R.getReplacementText())))

190 return

std::move(Err);

199

std::pair<FileID, unsigned> FileIDAndOffset =

202

assert(FE &&

"Cannot create AtomicChange with invalid location."

);

203

FilePath = std::string(FE->

getName

());

204

Key = FilePath +

":"

+ std::to_string(FileIDAndOffset.second);

210

Metadata = std::move(M);

213

AtomicChange::AtomicChange(std::string Key, std::string FilePath,

215

std::vector<std::string> InsertedHeaders,

216

std::vector<std::string> RemovedHeaders,

218

: Key(

std

::move(Key)), FilePath(

std

::move(FilePath)),

219

Error(

std

::move(Error)), InsertedHeaders(

std

::move(InsertedHeaders)),

220

RemovedHeaders(

std

::move(RemovedHeaders)), Replaces(

std

::move(Replaces)) {

224 if

(Key !=

Other

.Key || FilePath !=

Other

.FilePath || Error !=

Other

.Error)

226 if

(!(Replaces ==

Other

.Replaces))

233

std::string YamlContent;

234

llvm::raw_string_ostream YamlContentStream(YamlContent);

236

llvm::yaml::Output YAML(YamlContentStream);

242

NormalizedAtomicChange NE;

243

llvm::yaml::Input YAML(YAMLContent);

245 AtomicChange E

(NE.Key, NE.FilePath, NE.Error, NE.InsertedHeaders,

247 for

(

const auto

&R : NE.Replaces) {

248

llvm::Error Err =

.Replaces.add(R);

251 "Failed to add replacement when Converting YAML to AtomicChange."

);

252

llvm::consumeError(std::move(Err));

259

llvm::StringRef ReplacementText) {

264 unsigned

Length, llvm::StringRef

Text

) {

269

llvm::StringRef

Text

bool

InsertAfter) {

271 return

llvm::Error::success();

273

llvm::Error Err = Replaces.add(R);

275 return

llvm::handleErrors(

278 return

llvm::make_error<ReplacementError>(RE);

279 unsigned

NewOffset = Replaces.getShiftedCodePosition(R.

getOffset

());

285 return

llvm::Error::success();

288 return

llvm::Error::success();

292

InsertedHeaders.push_back(std::string(Header));

296

RemovedHeaders.push_back(std::string(Header));

304

createReplacementsForHeaders(FilePath, Code, Changes, Spec.

Style

);

305 if

(!HeaderReplacements)

307 "Failed to create replacements for header changes: "

308

llvm::toString(HeaderReplacements.takeError()));

311

combineReplacementsInChanges(FilePath, Changes);

314

llvm::toString(Replaces.takeError()));

317 for

(

const auto

&R : *HeaderReplacements) {

318

llvm::Error Err = AllReplaces.

add

(R);

321 "Failed to combine existing replacements with header replacements: "

322

llvm::toString(std::move(Err)));

330

llvm::toString(CleanReplaces.takeError()));

331

AllReplaces = std::move(*CleanReplaces);

339

llvm::toString(ChangedCode.takeError()));

349 "Failed to apply replacements for sorting includes: "

350

llvm::toString(ChangedCode.takeError()));

352

AllReplaces = AllReplaces.

merge

(HeaderSortingReplacements);

354

std::vector<Range> FormatRanges = getRangesForFormatting(

356 if

(!FormatRanges.empty()) {

362 "Failed to apply replacements for formatting changed code: "

363

llvm::toString(ChangedCode.takeError()));

This file defines the structure of a YAML document for serializing replacements.

Represents a character-granular source range.

StringRef getName() const

The name of this FileEntry.

A SourceLocation and its associated SourceManager.

FullSourceLoc getSpellingLoc() const

std::pair< FileID, unsigned > getDecomposedLoc() const

Decompose the specified location into a raw FileID + Offset pair.

Encodes a location in the source.

This class handles loading and caching of source files into memory.

Expected< tooling::Replacements > cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces, const FormatStyle &Style)

Returns the replacements corresponding to applying Replaces and cleaning up the code after that on su...

tooling::Replacements reformat(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>", FormattingAttemptStatus *Status=nullptr)

Reformats the given Ranges in Code.

tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName, unsigned *Cursor=nullptr)

Returns the replacements necessary to sort all #include blocks that are affected by Ranges.

The JSON file list parser is used to communicate input to InstallAPI.

if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))

@ Other

Other implicit parameter.

Diagnostic wrappers for TextAPI types for error reporting.

unsigned ColumnLimit

The column limit.

static void mapping(IO &Io, NormalizedAtomicChange &Doc)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4