Coverage Report

Created: 2022-01-22 13:19

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Format/TokenAnalyzer.cpp
Line
Count
Source (jump to first uncovered line)
1
//===--- TokenAnalyzer.cpp - Analyze Token Streams --------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
///
9
/// \file
10
/// This file implements an abstract TokenAnalyzer and associated helper
11
/// classes. TokenAnalyzer can be extended to generate replacements based on
12
/// an annotated and pre-processed token stream.
13
///
14
//===----------------------------------------------------------------------===//
15
16
#include "TokenAnalyzer.h"
17
#include "AffectedRangeManager.h"
18
#include "Encoding.h"
19
#include "FormatToken.h"
20
#include "FormatTokenLexer.h"
21
#include "TokenAnnotator.h"
22
#include "UnwrappedLineParser.h"
23
#include "clang/Basic/Diagnostic.h"
24
#include "clang/Basic/DiagnosticOptions.h"
25
#include "clang/Basic/FileManager.h"
26
#include "clang/Basic/SourceManager.h"
27
#include "clang/Format/Format.h"
28
#include "llvm/ADT/STLExtras.h"
29
#include "llvm/ADT/SmallVector.h"
30
#include "llvm/Support/Debug.h"
31
#include <type_traits>
32
33
#define DEBUG_TYPE "format-formatter"
34
35
namespace clang {
36
namespace format {
37
38
// FIXME: Instead of printing the diagnostic we should store it and have a
39
// better way to return errors through the format APIs.
40
class FatalDiagnosticConsumer : public DiagnosticConsumer {
41
public:
42
  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
43
0
                        const Diagnostic &Info) override {
44
0
    if (DiagLevel == DiagnosticsEngine::Fatal) {
45
0
      Fatal = true;
46
0
      llvm::SmallVector<char, 128> Message;
47
0
      Info.FormatDiagnostic(Message);
48
0
      llvm::errs() << Message << "\n";
49
0
    }
50
0
  }
51
52
49.4k
  bool fatalError() const { return Fatal; }
53
54
private:
55
  bool Fatal = false;
56
};
57
58
std::unique_ptr<Environment>
59
Environment::make(StringRef Code, StringRef FileName,
60
                  ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
61
49.4k
                  unsigned NextStartColumn, unsigned LastStartColumn) {
62
49.4k
  auto Env = std::make_unique<Environment>(Code, FileName, FirstStartColumn,
63
49.4k
                                           NextStartColumn, LastStartColumn);
64
49.4k
  FatalDiagnosticConsumer Diags;
65
49.4k
  Env->SM.getDiagnostics().setClient(&Diags, /*ShouldOwnClient=*/false);
66
49.4k
  SourceLocation StartOfFile = Env->SM.getLocForStartOfFile(Env->ID);
67
50.3k
  for (const tooling::Range &Range : Ranges) {
68
50.3k
    SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
69
50.3k
    SourceLocation End = Start.getLocWithOffset(Range.getLength());
70
50.3k
    Env->CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
71
50.3k
  }
72
  // Validate that we can get the buffer data without a fatal error.
73
49.4k
  Env->SM.getBufferData(Env->ID);
74
49.4k
  if (Diags.fatalError())
75
0
    return nullptr;
76
49.4k
  return Env;
77
49.4k
}
78
79
Environment::Environment(StringRef Code, StringRef FileName,
80
                         unsigned FirstStartColumn, unsigned NextStartColumn,
81
                         unsigned LastStartColumn)
82
    : VirtualSM(new SourceManagerForFile(FileName, Code)), SM(VirtualSM->get()),
83
      ID(VirtualSM->get().getMainFileID()), FirstStartColumn(FirstStartColumn),
84
49.8k
      NextStartColumn(NextStartColumn), LastStartColumn(LastStartColumn) {}
85
86
TokenAnalyzer::TokenAnalyzer(const Environment &Env, const FormatStyle &Style)
87
    : Style(Style), Env(Env),
88
      AffectedRangeMgr(Env.getSourceManager(), Env.getCharRanges()),
89
      UnwrappedLines(1),
90
      Encoding(encoding::detectEncoding(
91
49.8k
          Env.getSourceManager().getBufferData(Env.getFileID()))) {
92
49.8k
  LLVM_DEBUG(
93
49.8k
      llvm::dbgs() << "File encoding: "
94
49.8k
                   << (Encoding == encoding::Encoding_UTF8 ? "UTF8" : "unknown")
95
49.8k
                   << "\n");
96
49.8k
  LLVM_DEBUG(llvm::dbgs() << "Language: " << getLanguageName(Style.Language)
97
49.8k
                          << "\n");
98
49.8k
}
99
100
49.8k
std::pair<tooling::Replacements, unsigned> TokenAnalyzer::process() {
101
49.8k
  tooling::Replacements Result;
102
49.8k
  llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
103
49.8k
  IdentifierTable IdentTable(getFormattingLangOpts(Style));
104
49.8k
  FormatTokenLexer Lex(Env.getSourceManager(), Env.getFileID(),
105
49.8k
                       Env.getFirstStartColumn(), Style, Encoding, Allocator,
106
107
49.8k
                       IdentTable);
108
49.8k
  ArrayRef<FormatToken *> Toks(Lex.lex());
109
49.8k
  SmallVector<FormatToken *, 10> Tokens(Toks.begin(), Toks.end());
110
49.8k
  UnwrappedLineParser Parser(Style, Lex.getKeywords(),
111
49.8k
                             Env.getFirstStartColumn(), Tokens, *this);
112
49.8k
  Parser.parse();
113
49.8k
  assert(UnwrappedLines.rbegin()->empty());
114
0
  unsigned Penalty = 0;
115
100k
  for (unsigned Run = 0, RunE = UnwrappedLines.size(); Run + 1 != RunE; 
++Run50.3k
) {
116
50.3k
    LLVM_DEBUG(llvm::dbgs() << "Run " << Run << "...\n");
117
50.3k
    SmallVector<AnnotatedLine *, 16> AnnotatedLines;
118
119
50.3k
    TokenAnnotator Annotator(Style, Lex.getKeywords());
120
244k
    for (unsigned i = 0, e = UnwrappedLines[Run].size(); i != e; 
++i194k
) {
121
194k
      AnnotatedLines.push_back(new AnnotatedLine(UnwrappedLines[Run][i]));
122
194k
      Annotator.annotate(*AnnotatedLines.back());
123
194k
    }
124
125
50.3k
    std::pair<tooling::Replacements, unsigned> RunResult =
126
50.3k
        analyze(Annotator, AnnotatedLines, Lex);
127
128
50.3k
    LLVM_DEBUG({
129
50.3k
      llvm::dbgs() << "Replacements for run " << Run << ":\n";
130
50.3k
      for (const tooling::Replacement &Fix : RunResult.first)
131
50.3k
        llvm::dbgs() << Fix.toString() << "\n";
132
50.3k
    });
133
244k
    for (unsigned i = 0, e = AnnotatedLines.size(); i != e; 
++i194k
) {
134
194k
      delete AnnotatedLines[i];
135
194k
    }
136
137
50.3k
    Penalty += RunResult.second;
138
50.3k
    for (const auto &R : RunResult.first) {
139
29.0k
      auto Err = Result.add(R);
140
      // FIXME: better error handling here. For now, simply return an empty
141
      // Replacements to indicate failure.
142
29.0k
      if (Err) {
143
0
        llvm::errs() << llvm::toString(std::move(Err)) << "\n";
144
0
        return {tooling::Replacements(), 0};
145
0
      }
146
29.0k
    }
147
50.3k
  }
148
49.8k
  return {Result, Penalty};
149
49.8k
}
150
151
194k
void TokenAnalyzer::consumeUnwrappedLine(const UnwrappedLine &TheLine) {
152
194k
  assert(!UnwrappedLines.empty());
153
0
  UnwrappedLines.back().push_back(TheLine);
154
194k
}
155
156
50.3k
void TokenAnalyzer::finishRun() {
157
50.3k
  UnwrappedLines.push_back(SmallVector<UnwrappedLine, 16>());
158
50.3k
}
159
160
} // end namespace format
161
} // end namespace clang