clang  9.0.0svn
InterpolatingCompilationDatabase.cpp
Go to the documentation of this file.
1 //===- InterpolatingCompilationDatabase.cpp ---------------------*- 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 // InterpolatingCompilationDatabase wraps another CompilationDatabase and
10 // attempts to heuristically determine appropriate compile commands for files
11 // that are not included, such as headers or newly created files.
12 //
13 // Motivating cases include:
14 // Header files that live next to their implementation files. These typically
15 // share a base filename. (libclang/CXString.h, libclang/CXString.cpp).
16 // Some projects separate headers from includes. Filenames still typically
17 // match, maybe other path segments too. (include/llvm/IR/Use.h, lib/IR/Use.cc).
18 // Matches are sometimes only approximate (Sema.h, SemaDecl.cpp). This goes
19 // for directories too (Support/Unix/Process.inc, lib/Support/Process.cpp).
20 // Even if we can't find a "right" compile command, even a random one from
21 // the project will tend to get important flags like -I and -x right.
22 //
23 // We "borrow" the compile command for the closest available file:
24 // - points are awarded if the filename matches (ignoring extension)
25 // - points are awarded if the directory structure matches
26 // - ties are broken by length of path prefix match
27 //
28 // The compile command is adjusted, replacing the filename and removing output
29 // file arguments. The -x and -std flags may be affected too.
30 //
31 // Source language is a tricky issue: is it OK to use a .c file's command
32 // for building a .cc file? What language is a .h file in?
33 // - We only consider compile commands for c-family languages as candidates.
34 // - For files whose language is implied by the filename (e.g. .m, .hpp)
35 // we prefer candidates from the same language.
36 // If we must cross languages, we drop any -x and -std flags.
37 // - For .h files, candidates from any c-family language are acceptable.
38 // We use the candidate's language, inserting e.g. -x c++-header.
39 //
40 // This class is only useful when wrapping databases that can enumerate all
41 // their compile commands. If getAllFilenames() is empty, no inference occurs.
42 //
43 //===----------------------------------------------------------------------===//
44 
45 #include "clang/Driver/Options.h"
46 #include "clang/Driver/Types.h"
49 #include "llvm/ADT/DenseMap.h"
50 #include "llvm/ADT/Optional.h"
51 #include "llvm/ADT/StringExtras.h"
52 #include "llvm/ADT/StringSwitch.h"
53 #include "llvm/Option/ArgList.h"
54 #include "llvm/Option/OptTable.h"
55 #include "llvm/Support/Debug.h"
56 #include "llvm/Support/Path.h"
57 #include "llvm/Support/StringSaver.h"
58 #include "llvm/Support/raw_ostream.h"
59 #include <memory>
60 
61 namespace clang {
62 namespace tooling {
63 namespace {
64 using namespace llvm;
65 namespace types = clang::driver::types;
66 namespace path = llvm::sys::path;
67 
68 // The length of the prefix these two strings have in common.
69 size_t matchingPrefix(StringRef L, StringRef R) {
70  size_t Limit = std::min(L.size(), R.size());
71  for (size_t I = 0; I < Limit; ++I)
72  if (L[I] != R[I])
73  return I;
74  return Limit;
75 }
76 
77 // A comparator for searching SubstringWithIndexes with std::equal_range etc.
78 // Optionaly prefix semantics: compares equal if the key is a prefix.
79 template <bool Prefix> struct Less {
80  bool operator()(StringRef Key, std::pair<StringRef, size_t> Value) const {
81  StringRef V = Prefix ? Value.first.substr(0, Key.size()) : Value.first;
82  return Key < V;
83  }
84  bool operator()(std::pair<StringRef, size_t> Value, StringRef Key) const {
85  StringRef V = Prefix ? Value.first.substr(0, Key.size()) : Value.first;
86  return V < Key;
87  }
88 };
89 
90 // Infer type from filename. If we might have gotten it wrong, set *Certain.
91 // *.h will be inferred as a C header, but not certain.
92 types::ID guessType(StringRef Filename, bool *Certain = nullptr) {
93  // path::extension is ".cpp", lookupTypeForExtension wants "cpp".
94  auto Lang =
95  types::lookupTypeForExtension(path::extension(Filename).substr(1));
96  if (Certain)
97  *Certain = Lang != types::TY_CHeader && Lang != types::TY_INVALID;
98  return Lang;
99 }
100 
101 // Return Lang as one of the canonical supported types.
102 // e.g. c-header --> c; fortran --> TY_INVALID
103 static types::ID foldType(types::ID Lang) {
104  switch (Lang) {
105  case types::TY_C:
106  case types::TY_CHeader:
107  return types::TY_C;
108  case types::TY_ObjC:
109  case types::TY_ObjCHeader:
110  return types::TY_ObjC;
111  case types::TY_CXX:
112  case types::TY_CXXHeader:
113  return types::TY_CXX;
114  case types::TY_ObjCXX:
115  case types::TY_ObjCXXHeader:
116  return types::TY_ObjCXX;
117  default:
118  return types::TY_INVALID;
119  }
120 }
121 
122 // A CompileCommand that can be applied to another file.
123 struct TransferableCommand {
124  // Flags that should not apply to all files are stripped from CommandLine.
125  CompileCommand Cmd;
126  // Language detected from -x or the filename. Never TY_INVALID.
128  // Standard specified by -std.
130  // Whether the command line is for the cl-compatible driver.
132 
133  TransferableCommand(CompileCommand C)
134  : Cmd(std::move(C)), Type(guessType(Cmd.Filename)),
135  ClangCLMode(checkIsCLMode(Cmd.CommandLine)) {
136  std::vector<std::string> OldArgs = std::move(Cmd.CommandLine);
137  Cmd.CommandLine.clear();
138 
139  // Wrap the old arguments in an InputArgList.
140  llvm::opt::InputArgList ArgList;
141  {
143  for (const std::string &S : OldArgs)
144  TmpArgv.push_back(S.c_str());
145  ArgList = {TmpArgv.begin(), TmpArgv.end()};
146  }
147 
148  // Parse the old args in order to strip out and record unwanted flags.
149  // We parse each argument individually so that we can retain the exact
150  // spelling of each argument; re-rendering is lossy for aliased flags.
151  // E.g. in CL mode, /W4 maps to -Wall.
152  auto OptTable = clang::driver::createDriverOptTable();
153  Cmd.CommandLine.emplace_back(OldArgs.front());
154  for (unsigned Pos = 1; Pos < OldArgs.size();) {
155  using namespace driver::options;
156 
157  const unsigned OldPos = Pos;
158  std::unique_ptr<llvm::opt::Arg> Arg(OptTable->ParseOneArg(
159  ArgList, Pos,
160  /* Include */ClangCLMode ? CoreOption | CLOption : 0,
161  /* Exclude */ClangCLMode ? 0 : CLOption));
162 
163  if (!Arg)
164  continue;
165 
166  const llvm::opt::Option &Opt = Arg->getOption();
167 
168  // Strip input and output files.
169  if (Opt.matches(OPT_INPUT) || Opt.matches(OPT_o) ||
170  (ClangCLMode && (Opt.matches(OPT__SLASH_Fa) ||
171  Opt.matches(OPT__SLASH_Fe) ||
172  Opt.matches(OPT__SLASH_Fi) ||
173  Opt.matches(OPT__SLASH_Fo))))
174  continue;
175 
176  // Strip -x, but record the overridden language.
177  if (const auto GivenType = tryParseTypeArg(*Arg)) {
178  Type = *GivenType;
179  continue;
180  }
181 
182  // Strip -std, but record the value.
183  if (const auto GivenStd = tryParseStdArg(*Arg)) {
184  if (*GivenStd != LangStandard::lang_unspecified)
185  Std = *GivenStd;
186  continue;
187  }
188 
189  Cmd.CommandLine.insert(Cmd.CommandLine.end(),
190  OldArgs.data() + OldPos, OldArgs.data() + Pos);
191  }
192 
193  if (Std != LangStandard::lang_unspecified) // -std take precedence over -x
194  Type = toType(LangStandard::getLangStandardForKind(Std).getLanguage());
195  Type = foldType(*Type);
196  // The contract is to store None instead of TY_INVALID.
197  if (Type == types::TY_INVALID)
198  Type = llvm::None;
199  }
200 
201  // Produce a CompileCommand for \p filename, based on this one.
202  CompileCommand transferTo(StringRef Filename) const {
203  CompileCommand Result = Cmd;
204  Result.Filename = Filename;
205  bool TypeCertain;
206  auto TargetType = guessType(Filename, &TypeCertain);
207  // If the filename doesn't determine the language (.h), transfer with -x.
208  if ((!TargetType || !TypeCertain) && Type) {
209  // Use *Type, or its header variant if the file is a header.
210  // Treat no/invalid extension as header (e.g. C++ standard library).
211  TargetType =
212  (!TargetType || types::onlyPrecompileType(TargetType)) // header?
214  : *Type;
215  if (ClangCLMode) {
216  const StringRef Flag = toCLFlag(TargetType);
217  if (!Flag.empty())
218  Result.CommandLine.push_back(Flag);
219  } else {
220  Result.CommandLine.push_back("-x");
221  Result.CommandLine.push_back(types::getTypeName(TargetType));
222  }
223  }
224  // --std flag may only be transferred if the language is the same.
225  // We may consider "translating" these, e.g. c++11 -> c11.
226  if (Std != LangStandard::lang_unspecified && foldType(TargetType) == Type) {
227  Result.CommandLine.emplace_back((
228  llvm::Twine(ClangCLMode ? "/std:" : "-std=") +
230  }
231  Result.CommandLine.push_back(Filename);
232  Result.Heuristic = "inferred from " + Cmd.Filename;
233  return Result;
234  }
235 
236 private:
237  // Determine whether the given command line is intended for the CL driver.
238  static bool checkIsCLMode(ArrayRef<std::string> CmdLine) {
239  // First look for --driver-mode.
240  for (StringRef S : llvm::reverse(CmdLine)) {
241  if (S.consume_front("--driver-mode="))
242  return S == "cl";
243  }
244 
245  // Otherwise just check the clang executable file name.
246  return llvm::sys::path::stem(CmdLine.front()).endswith_lower("cl");
247  }
248 
249  // Map the language from the --std flag to that of the -x flag.
250  static types::ID toType(InputKind::Language Lang) {
251  switch (Lang) {
252  case InputKind::C:
253  return types::TY_C;
254  case InputKind::CXX:
255  return types::TY_CXX;
256  case InputKind::ObjC:
257  return types::TY_ObjC;
258  case InputKind::ObjCXX:
259  return types::TY_ObjCXX;
260  default:
261  return types::TY_INVALID;
262  }
263  }
264 
265  // Convert a file type to the matching CL-style type flag.
266  static StringRef toCLFlag(types::ID Type) {
267  switch (Type) {
268  case types::TY_C:
269  case types::TY_CHeader:
270  return "/TC";
271  case types::TY_CXX:
272  case types::TY_CXXHeader:
273  return "/TP";
274  default:
275  return StringRef();
276  }
277  }
278 
279  // Try to interpret the argument as a type specifier, e.g. '-x'.
280  Optional<types::ID> tryParseTypeArg(const llvm::opt::Arg &Arg) {
281  const llvm::opt::Option &Opt = Arg.getOption();
282  using namespace driver::options;
283  if (ClangCLMode) {
284  if (Opt.matches(OPT__SLASH_TC) || Opt.matches(OPT__SLASH_Tc))
285  return types::TY_C;
286  if (Opt.matches(OPT__SLASH_TP) || Opt.matches(OPT__SLASH_Tp))
287  return types::TY_CXX;
288  } else {
289  if (Opt.matches(driver::options::OPT_x))
290  return types::lookupTypeForTypeSpecifier(Arg.getValue());
291  }
292  return None;
293  }
294 
295  // Try to interpret the argument as '-std='.
296  Optional<LangStandard::Kind> tryParseStdArg(const llvm::opt::Arg &Arg) {
297  using namespace driver::options;
298  if (Arg.getOption().matches(ClangCLMode ? OPT__SLASH_std : OPT_std_EQ)) {
299  return llvm::StringSwitch<LangStandard::Kind>(Arg.getValue())
300 #define LANGSTANDARD(id, name, lang, ...) .Case(name, LangStandard::lang_##id)
301 #define LANGSTANDARD_ALIAS(id, alias) .Case(alias, LangStandard::lang_##id)
302 #include "clang/Frontend/LangStandards.def"
303 #undef LANGSTANDARD_ALIAS
304 #undef LANGSTANDARD
306  }
307  return None;
308  }
309 };
310 
311 // Given a filename, FileIndex picks the best matching file from the underlying
312 // DB. This is the proxy file whose CompileCommand will be reused. The
313 // heuristics incorporate file name, extension, and directory structure.
314 // Strategy:
315 // - Build indexes of each of the substrings we want to look up by.
316 // These indexes are just sorted lists of the substrings.
317 // - Each criterion corresponds to a range lookup into the index, so we only
318 // need O(log N) string comparisons to determine scores.
319 //
320 // Apart from path proximity signals, also takes file extensions into account
321 // when scoring the candidates.
322 class FileIndex {
323 public:
324  FileIndex(std::vector<std::string> Files)
325  : OriginalPaths(std::move(Files)), Strings(Arena) {
326  // Sort commands by filename for determinism (index is a tiebreaker later).
327  llvm::sort(OriginalPaths);
328  Paths.reserve(OriginalPaths.size());
329  Types.reserve(OriginalPaths.size());
330  Stems.reserve(OriginalPaths.size());
331  for (size_t I = 0; I < OriginalPaths.size(); ++I) {
332  StringRef Path = Strings.save(StringRef(OriginalPaths[I]).lower());
333 
334  Paths.emplace_back(Path, I);
335  Types.push_back(foldType(guessType(Path)));
336  Stems.emplace_back(sys::path::stem(Path), I);
337  auto Dir = ++sys::path::rbegin(Path), DirEnd = sys::path::rend(Path);
338  for (int J = 0; J < DirectorySegmentsIndexed && Dir != DirEnd; ++J, ++Dir)
339  if (Dir->size() > ShortDirectorySegment) // not trivial ones
340  Components.emplace_back(*Dir, I);
341  }
342  llvm::sort(Paths);
343  llvm::sort(Stems);
344  llvm::sort(Components);
345  }
346 
347  bool empty() const { return Paths.empty(); }
348 
349  // Returns the path for the file that best fits OriginalFilename.
350  // Candidates with extensions matching PreferLanguage will be chosen over
351  // others (unless it's TY_INVALID, or all candidates are bad).
352  StringRef chooseProxy(StringRef OriginalFilename,
353  types::ID PreferLanguage) const {
354  assert(!empty() && "need at least one candidate!");
355  std::string Filename = OriginalFilename.lower();
356  auto Candidates = scoreCandidates(Filename);
357  std::pair<size_t, int> Best =
358  pickWinner(Candidates, Filename, PreferLanguage);
359 
360  DEBUG_WITH_TYPE(
361  "interpolate",
362  llvm::dbgs() << "interpolate: chose " << OriginalPaths[Best.first]
363  << " as proxy for " << OriginalFilename << " preferring "
364  << (PreferLanguage == types::TY_INVALID
365  ? "none"
366  : types::getTypeName(PreferLanguage))
367  << " score=" << Best.second << "\n");
368  return OriginalPaths[Best.first];
369  }
370 
371 private:
372  using SubstringAndIndex = std::pair<StringRef, size_t>;
373  // Directory matching parameters: we look at the last two segments of the
374  // parent directory (usually the semantically significant ones in practice).
375  // We search only the last four of each candidate (for efficiency).
376  constexpr static int DirectorySegmentsIndexed = 4;
377  constexpr static int DirectorySegmentsQueried = 2;
378  constexpr static int ShortDirectorySegment = 1; // Only look at longer names.
379 
380  // Award points to candidate entries that should be considered for the file.
381  // Returned keys are indexes into paths, and the values are (nonzero) scores.
382  DenseMap<size_t, int> scoreCandidates(StringRef Filename) const {
383  // Decompose Filename into the parts we care about.
384  // /some/path/complicated/project/Interesting.h
385  // [-prefix--][---dir---] [-dir-] [--stem---]
386  StringRef Stem = sys::path::stem(Filename);
388  llvm::StringRef Prefix;
389  auto Dir = ++sys::path::rbegin(Filename),
390  DirEnd = sys::path::rend(Filename);
391  for (int I = 0; I < DirectorySegmentsQueried && Dir != DirEnd; ++I, ++Dir) {
392  if (Dir->size() > ShortDirectorySegment)
393  Dirs.push_back(*Dir);
394  Prefix = Filename.substr(0, Dir - DirEnd);
395  }
396 
397  // Now award points based on lookups into our various indexes.
398  DenseMap<size_t, int> Candidates; // Index -> score.
399  auto Award = [&](int Points, ArrayRef<SubstringAndIndex> Range) {
400  for (const auto &Entry : Range)
401  Candidates[Entry.second] += Points;
402  };
403  // Award one point if the file's basename is a prefix of the candidate,
404  // and another if it's an exact match (so exact matches get two points).
405  Award(1, indexLookup</*Prefix=*/true>(Stem, Stems));
406  Award(1, indexLookup</*Prefix=*/false>(Stem, Stems));
407  // For each of the last few directories in the Filename, award a point
408  // if it's present in the candidate.
409  for (StringRef Dir : Dirs)
410  Award(1, indexLookup</*Prefix=*/false>(Dir, Components));
411  // Award one more point if the whole rest of the path matches.
412  if (sys::path::root_directory(Prefix) != Prefix)
413  Award(1, indexLookup</*Prefix=*/true>(Prefix, Paths));
414  return Candidates;
415  }
416 
417  // Pick a single winner from the set of scored candidates.
418  // Returns (index, score).
419  std::pair<size_t, int> pickWinner(const DenseMap<size_t, int> &Candidates,
420  StringRef Filename,
421  types::ID PreferredLanguage) const {
422  struct ScoredCandidate {
423  size_t Index;
424  bool Preferred;
425  int Points;
426  size_t PrefixLength;
427  };
428  // Choose the best candidate by (preferred, points, prefix length, alpha).
429  ScoredCandidate Best = {size_t(-1), false, 0, 0};
430  for (const auto &Candidate : Candidates) {
431  ScoredCandidate S;
432  S.Index = Candidate.first;
433  S.Preferred = PreferredLanguage == types::TY_INVALID ||
434  PreferredLanguage == Types[S.Index];
435  S.Points = Candidate.second;
436  if (!S.Preferred && Best.Preferred)
437  continue;
438  if (S.Preferred == Best.Preferred) {
439  if (S.Points < Best.Points)
440  continue;
441  if (S.Points == Best.Points) {
442  S.PrefixLength = matchingPrefix(Filename, Paths[S.Index].first);
443  if (S.PrefixLength < Best.PrefixLength)
444  continue;
445  // hidden heuristics should at least be deterministic!
446  if (S.PrefixLength == Best.PrefixLength)
447  if (S.Index > Best.Index)
448  continue;
449  }
450  }
451  // PrefixLength was only set above if actually needed for a tiebreak.
452  // But it definitely needs to be set to break ties in the future.
453  S.PrefixLength = matchingPrefix(Filename, Paths[S.Index].first);
454  Best = S;
455  }
456  // Edge case: no candidate got any points.
457  // We ignore PreferredLanguage at this point (not ideal).
458  if (Best.Index == size_t(-1))
459  return {longestMatch(Filename, Paths).second, 0};
460  return {Best.Index, Best.Points};
461  }
462 
463  // Returns the range within a sorted index that compares equal to Key.
464  // If Prefix is true, it's instead the range starting with Key.
465  template <bool Prefix>
467  indexLookup(StringRef Key, ArrayRef<SubstringAndIndex> Idx) const {
468  // Use pointers as iteratiors to ease conversion of result to ArrayRef.
469  auto Range = std::equal_range(Idx.data(), Idx.data() + Idx.size(), Key,
470  Less<Prefix>());
471  return {Range.first, Range.second};
472  }
473 
474  // Performs a point lookup into a nonempty index, returning a longest match.
475  SubstringAndIndex longestMatch(StringRef Key,
476  ArrayRef<SubstringAndIndex> Idx) const {
477  assert(!Idx.empty());
478  // Longest substring match will be adjacent to a direct lookup.
479  auto It =
480  std::lower_bound(Idx.begin(), Idx.end(), SubstringAndIndex{Key, 0});
481  if (It == Idx.begin())
482  return *It;
483  if (It == Idx.end())
484  return *--It;
485  // Have to choose between It and It-1
486  size_t Prefix = matchingPrefix(Key, It->first);
487  size_t PrevPrefix = matchingPrefix(Key, (It - 1)->first);
488  return Prefix > PrevPrefix ? *It : *--It;
489  }
490 
491  // Original paths, everything else is in lowercase.
492  std::vector<std::string> OriginalPaths;
493  BumpPtrAllocator Arena;
494  StringSaver Strings;
495  // Indexes of candidates by certain substrings.
496  // String is lowercase and sorted, index points into OriginalPaths.
497  std::vector<SubstringAndIndex> Paths; // Full path.
498  // Lang types obtained by guessing on the corresponding path. I-th element is
499  // a type for the I-th path.
500  std::vector<types::ID> Types;
501  std::vector<SubstringAndIndex> Stems; // Basename, without extension.
502  std::vector<SubstringAndIndex> Components; // Last path components.
503 };
504 
505 // The actual CompilationDatabase wrapper delegates to its inner database.
506 // If no match, looks up a proxy file in FileIndex and transfers its
507 // command to the requested file.
508 class InterpolatingCompilationDatabase : public CompilationDatabase {
509 public:
510  InterpolatingCompilationDatabase(std::unique_ptr<CompilationDatabase> Inner)
511  : Inner(std::move(Inner)), Index(this->Inner->getAllFiles()) {}
512 
513  std::vector<CompileCommand>
514  getCompileCommands(StringRef Filename) const override {
515  auto Known = Inner->getCompileCommands(Filename);
516  if (Index.empty() || !Known.empty())
517  return Known;
518  bool TypeCertain;
519  auto Lang = guessType(Filename, &TypeCertain);
520  if (!TypeCertain)
521  Lang = types::TY_INVALID;
522  auto ProxyCommands =
523  Inner->getCompileCommands(Index.chooseProxy(Filename, foldType(Lang)));
524  if (ProxyCommands.empty())
525  return {};
526  return {TransferableCommand(ProxyCommands[0]).transferTo(Filename)};
527  }
528 
529  std::vector<std::string> getAllFiles() const override {
530  return Inner->getAllFiles();
531  }
532 
533  std::vector<CompileCommand> getAllCompileCommands() const override {
534  return Inner->getAllCompileCommands();
535  }
536 
537 private:
538  std::unique_ptr<CompilationDatabase> Inner;
539  FileIndex Index;
540 };
541 
542 } // namespace
543 
544 std::unique_ptr<CompilationDatabase>
545 inferMissingCompileCommands(std::unique_ptr<CompilationDatabase> Inner) {
546  return llvm::make_unique<InterpolatingCompilationDatabase>(std::move(Inner));
547 }
548 
549 } // namespace tooling
550 } // namespace clang
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:67
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:29
static const LangStandard & getLangStandardForKind(Kind K)
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
Definition: Format.h:2222
Languages that the frontend can parse and compile.
CompileCommand Cmd
std::unique_ptr< llvm::opt::OptTable > createDriverOptTable()
return Out str()
StringRef Filename
Definition: Format.cpp:1707
ID lookupHeaderTypeForSourceType(ID Id)
Lookup header file input type that corresponds to given source file type (used for clang-cl emulation...
Definition: Types.cpp:309
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
Definition: Types.cpp:38
#define V(N, I)
Definition: ASTContext.h:2905
std::unique_ptr< CompilationDatabase > inferMissingCompileCommands(std::unique_ptr< CompilationDatabase >)
Returns a wrapped CompilationDatabase that defers to the provided one, but getCompileCommands() will ...
Optional< types::ID > Type
Dataflow Directional Tag Classes.
Language
The language for the input, used to select and validate the language standard and possible actions...
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
Definition: Types.cpp:194
bool onlyPrecompileType(ID Id)
onlyPrecompileType - Should this type only be precompiled.
Definition: Types.cpp:75
#define LANGSTANDARD(id, name, lang,...)
__DEVICE__ int min(int __a, int __b)
ID lookupTypeForTypeSpecifier(const char *Name)
lookupTypeForTypSpecifier - Lookup the type to use for a user specified type name.
Definition: Types.cpp:255
A node that&#39;s not selected.
LangStandard::Kind Std