clang 19.0.0git
SValBuilder.h
Go to the documentation of this file.
1// SValBuilder.h - Construction of SVals from evaluating expressions -*- 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// This file defines SValBuilder, a class that defines the interface for
10// "symbolical evaluators" which construct an SVal from an expression.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALBUILDER_H
15#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALBUILDER_H
16
19#include "clang/AST/Expr.h"
20#include "clang/AST/ExprObjC.h"
21#include "clang/AST/Type.h"
22#include "clang/Basic/LLVM.h"
30#include "llvm/ADT/ImmutableList.h"
31#include <cstdint>
32#include <optional>
33
34namespace clang {
35
36class AnalyzerOptions;
37class BlockDecl;
38class CXXBoolLiteralExpr;
39class CXXMethodDecl;
40class CXXRecordDecl;
41class DeclaratorDecl;
42class FunctionDecl;
43class LocationContext;
44class StackFrameContext;
45class Stmt;
46
47namespace ento {
48
49class ConditionTruthVal;
50class ProgramStateManager;
51class StoreRef;
52
54 virtual void anchor();
55
56protected:
58
59 /// Manager of APSInt values.
61
62 /// Manages the creation of symbols.
64
65 /// Manages the creation of memory regions.
67
69
71
72 /// The scalar type to use for array indices.
74
75 /// The width of the scalar type used for array indices.
76 const unsigned ArrayIndexWidth;
77
78public:
79 SValBuilder(llvm::BumpPtrAllocator &alloc, ASTContext &context,
80 ProgramStateManager &stateMgr);
81
82 virtual ~SValBuilder() = default;
83
84 SVal evalCast(SVal V, QualType CastTy, QualType OriginalTy);
85
86 // Handles casts of type CK_IntegralCast.
88 QualType originalType);
89
92
93 /// Create a new value which represents a binary expression with two non-
94 /// location operands.
96 NonLoc lhs, NonLoc rhs, QualType resultTy) = 0;
97
98 /// Create a new value which represents a binary expression with two memory
99 /// location operands.
101 Loc lhs, Loc rhs, QualType resultTy) = 0;
102
103 /// Create a new value which represents a binary expression with a memory
104 /// location and non-location operands. For example, this would be used to
105 /// evaluate a pointer arithmetic operation.
107 Loc lhs, NonLoc rhs, QualType resultTy) = 0;
108
109 /// Evaluates a given SVal. If the SVal has only one possible (integer) value,
110 /// that value is returned. Otherwise, returns NULL.
111 virtual const llvm::APSInt *getKnownValue(ProgramStateRef state, SVal val) = 0;
112
113 /// Tries to get the minimal possible (integer) value of a given SVal. This
114 /// always returns the value of a ConcreteInt, but may return NULL if the
115 /// value is symbolic and the constraint manager cannot provide a useful
116 /// answer.
117 virtual const llvm::APSInt *getMinValue(ProgramStateRef state, SVal val) = 0;
118
119 /// Tries to get the maximal possible (integer) value of a given SVal. This
120 /// always returns the value of a ConcreteInt, but may return NULL if the
121 /// value is symbolic and the constraint manager cannot provide a useful
122 /// answer.
123 virtual const llvm::APSInt *getMaxValue(ProgramStateRef state, SVal val) = 0;
124
125 /// Simplify symbolic expressions within a given SVal. Return an SVal
126 /// that represents the same value, but is hopefully easier to work with
127 /// than the original SVal.
128 virtual SVal simplifySVal(ProgramStateRef State, SVal Val) = 0;
129
130 /// Constructs a symbolic expression for two non-location values.
132 NonLoc lhs, NonLoc rhs, QualType resultTy);
133
135 SVal operand, QualType type);
136
138 SVal lhs, SVal rhs, QualType type);
139
140 /// \return Whether values in \p lhs and \p rhs are equal at \p state.
142
143 SVal evalEQ(ProgramStateRef state, SVal lhs, SVal rhs);
144
147
149 const ASTContext &getContext() const { return Context; }
150
152
154 return Context.getLangOpts().CPlusPlus ? Context.BoolTy : Context.IntTy;
155 }
156
158 return ArrayIndexTy;
159 }
160
163
165 const SymbolManager &getSymbolManager() const { return SymMgr; }
166
168 const MemRegionManager &getRegionManager() const { return MemMgr; }
169
170 const AnalyzerOptions &getAnalyzerOptions() const { return AnOpts; }
171
172 // Forwarding methods to SymbolManager.
173
175 const LocationContext *LCtx,
177 unsigned visitCount,
178 const void *symbolTag = nullptr) {
179 return SymMgr.conjureSymbol(stmt, LCtx, type, visitCount, symbolTag);
180 }
181
183 const LocationContext *LCtx,
184 unsigned visitCount,
185 const void *symbolTag = nullptr) {
186 return SymMgr.conjureSymbol(expr, LCtx, visitCount, symbolTag);
187 }
188
189 /// Construct an SVal representing '0' for the specified type.
191
192 /// Make a unique symbol for value of region.
194
195 /// Create a new symbol with a unique 'name'.
196 ///
197 /// We resort to conjured symbols when we cannot construct a derived symbol.
198 /// The advantage of symbols derived/built from other symbols is that we
199 /// preserve the relation between related(or even equivalent) expressions, so
200 /// conjured symbols should be used sparingly.
201 DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag,
202 const Expr *expr,
203 const LocationContext *LCtx,
204 unsigned count);
205 DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag,
206 const Expr *expr,
207 const LocationContext *LCtx,
209 unsigned count);
211 const LocationContext *LCtx,
213 unsigned visitCount);
214
215 /// Conjure a symbol representing heap allocated memory region.
216 ///
217 /// Note, the expression should represent a location.
219 const LocationContext *LCtx,
220 unsigned Count);
221
222 /// Conjure a symbol representing heap allocated memory region.
223 ///
224 /// Note, now, the expression *doesn't* need to represent a location.
225 /// But the type need to!
227 const LocationContext *LCtx,
228 QualType type, unsigned Count);
229
230 /// Create an SVal representing the result of an alloca()-like call, that is,
231 /// an AllocaRegion on the stack.
232 ///
233 /// After calling this function, it's a good idea to set the extent of the
234 /// returned AllocaRegion.
236 const LocationContext *LCtx,
237 unsigned Count);
238
240 SymbolRef parentSymbol, const TypedValueRegion *region);
241
242 DefinedSVal getMetadataSymbolVal(const void *symbolTag,
243 const MemRegion *region,
244 const Expr *expr, QualType type,
245 const LocationContext *LCtx,
246 unsigned count);
247
249
251
253 const LocationContext *locContext,
254 unsigned blockCount);
255
256 /// Returns the value of \p E, if it can be determined in a non-path-sensitive
257 /// manner.
258 ///
259 /// If \p E is not a constant or cannot be modeled, returns \c std::nullopt.
260 std::optional<SVal> getConstantVal(const Expr *E);
261
262 NonLoc makeCompoundVal(QualType type, llvm::ImmutableList<SVal> vals) {
264 }
265
267 const TypedValueRegion *region) {
269 BasicVals.getLazyCompoundValData(store, region));
270 }
271
273 return nonloc::PointerToMember(DD);
274 }
275
277 return nonloc::PointerToMember(PTMD);
278 }
279
281 return nonloc::ConcreteInt(BasicVals.getValue(0, ArrayIndexTy));
282 }
283
284 NonLoc makeArrayIndex(uint64_t idx) {
285 return nonloc::ConcreteInt(BasicVals.getValue(idx, ArrayIndexTy));
286 }
287
289
291 return nonloc::ConcreteInt(
292 BasicVals.getValue(integer->getValue(),
294 }
295
297 return makeTruthVal(boolean->getValue(), boolean->getType());
298 }
299
301
302 nonloc::ConcreteInt makeIntVal(const llvm::APSInt& integer) {
303 return nonloc::ConcreteInt(BasicVals.getValue(integer));
304 }
305
306 loc::ConcreteInt makeIntLocVal(const llvm::APSInt &integer) {
307 return loc::ConcreteInt(BasicVals.getValue(integer));
308 }
309
310 NonLoc makeIntVal(const llvm::APInt& integer, bool isUnsigned) {
311 return nonloc::ConcreteInt(BasicVals.getValue(integer, isUnsigned));
312 }
313
314 DefinedSVal makeIntVal(uint64_t integer, QualType type) {
315 if (Loc::isLocType(type))
316 return loc::ConcreteInt(BasicVals.getValue(integer, type));
317
318 return nonloc::ConcreteInt(BasicVals.getValue(integer, type));
319 }
320
321 NonLoc makeIntVal(uint64_t integer, bool isUnsigned) {
323 }
324
325 NonLoc makeIntValWithWidth(QualType ptrType, uint64_t integer) {
326 return nonloc::ConcreteInt(BasicVals.getValue(integer, ptrType));
327 }
328
329 NonLoc makeLocAsInteger(Loc loc, unsigned bits) {
331 }
332
334 const llvm::APSInt &rhs, QualType type);
335
336 nonloc::SymbolVal makeNonLoc(const llvm::APSInt &rhs,
337 BinaryOperator::Opcode op, const SymExpr *lhs,
338 QualType type);
339
341 const SymExpr *rhs, QualType type);
342
344 QualType type);
345
346 /// Create a NonLoc value for cast.
347 nonloc::SymbolVal makeNonLoc(const SymExpr *operand, QualType fromTy,
348 QualType toTy);
349
352 }
353
356 }
357
358 /// Create NULL pointer, with proper pointer bit-width for given address
359 /// space.
360 /// \param type pointer type.
362 // We cannot use the `isAnyPointerType()`.
363 assert((type->isPointerType() || type->isObjCObjectPointerType() ||
364 type->isBlockPointerType() || type->isNullPtrType() ||
365 type->isReferenceType()) &&
366 "makeNullWithType must use pointer type");
367
368 // The `sizeof(T&)` is `sizeof(T)`, thus we replace the reference with a
369 // pointer. Here we assume that references are actually implemented by
370 // pointers under-the-hood.
371 type = type->isReferenceType()
372 ? Context.getPointerType(type->getPointeeType())
373 : type;
375 }
376
379 }
380
382 return loc::MemRegionVal(region);
383 }
384
386 return loc::GotoLabel(expr->getLabel());
387 }
388
389 loc::ConcreteInt makeLoc(const llvm::APSInt &integer) {
390 return loc::ConcreteInt(BasicVals.getValue(integer));
391 }
392
393 /// Return MemRegionVal on success cast, otherwise return std::nullopt.
394 std::optional<loc::MemRegionVal>
396
397 /// Make an SVal that represents the given symbol. This follows the convention
398 /// of representing Loc-type symbols (symbolic pointers and references)
399 /// as Loc values wrapping the symbol rather than as plain symbol values.
401 if (Loc::isLocType(Sym->getType()))
402 return makeLoc(Sym);
403 return nonloc::SymbolVal(Sym);
404 }
405
406 /// Return a memory region for the 'this' object reference.
408 const StackFrameContext *SFC);
409
410 /// Return a memory region for the 'this' object reference.
412 const StackFrameContext *SFC);
413};
414
415SValBuilder* createSimpleSValBuilder(llvm::BumpPtrAllocator &alloc,
416 ASTContext &context,
417 ProgramStateManager &stateMgr);
418
419} // namespace ento
420
421} // namespace clang
422
423#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SVALBUILDER_H
Defines the clang::ASTContext interface.
#define V(N, I)
Definition: ASTContext.h:3273
static bool isUnsigned(SValBuilder &SVB, NonLoc Value)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
C Language Family Type Representation.
__device__ __2f16 b
llvm::APInt getValue() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const LangOptions & getLangOpts() const
Definition: ASTContext.h:775
CanQualType BoolTy
Definition: ASTContext.h:1092
CanQualType IntTy
Definition: ASTContext.h:1100
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:4338
Stores options for the analyzer from the command line.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4495
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:720
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2057
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:770
This represents one expression.
Definition: Expr.h:110
QualType getType() const
Definition: Expr.h:142
Represents a function declaration or definition.
Definition: Decl.h:1971
It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext ...
This represents a decl that may have a name.
Definition: Decl.h:249
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:87
A (possibly-)qualified type.
Definition: Type.h:738
It represents a stack frame of the call stack (based on CallEvent).
Stmt - This represents one statement.
Definition: Stmt.h:84
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:2205
const CompoundValData * getCompoundValData(QualType T, llvm::ImmutableList< SVal > Vals)
const llvm::APSInt & getTruthValue(bool b, QualType T)
const std::pair< SVal, uintptr_t > & getPersistentSValWithData(const SVal &V, uintptr_t Data)
const llvm::APSInt & getIntValue(uint64_t X, bool isUnsigned)
const LazyCompoundValData * getLazyCompoundValData(const StoreRef &store, const TypedValueRegion *region)
const llvm::APSInt & getZeroWithTypeSize(QualType T)
static bool isLocType(QualType T)
Definition: SVals.h:259
const SymbolicRegion * getSymbolicRegion(SymbolRef Sym, const MemSpaceRegion *MemSpace=nullptr)
Retrieve or create a "symbolic" memory region.
Definition: MemRegion.cpp:1192
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:96
const SymbolConjured * conjureSymbol(const Stmt *stmt, const LocationContext *LCtx, QualType type, unsigned visitCount, const void *symbolTag=nullptr)
Definition: SValBuilder.h:174
DefinedOrUnknownSVal makeZeroVal(QualType type)
Construct an SVal representing '0' for the specified type.
Definition: SValBuilder.cpp:62
DefinedSVal getMemberPointer(const NamedDecl *ND)
NonLoc makePointerToMember(const DeclaratorDecl *DD)
Definition: SValBuilder.h:272
SVal evalMinus(NonLoc val)
SVal evalComplement(NonLoc val)
virtual const llvm::APSInt * getKnownValue(ProgramStateRef state, SVal val)=0
Evaluates a given SVal.
BasicValueFactory & getBasicValueFactory()
Definition: SValBuilder.h:161
loc::ConcreteInt makeLoc(const llvm::APSInt &integer)
Definition: SValBuilder.h:389
NonLoc makeCompoundVal(QualType type, llvm::ImmutableList< SVal > vals)
Definition: SValBuilder.h:262
SymbolManager SymMgr
Manages the creation of symbols.
Definition: SValBuilder.h:63
virtual SVal evalBinOpLN(ProgramStateRef state, BinaryOperator::Opcode op, Loc lhs, NonLoc rhs, QualType resultTy)=0
Create a new value which represents a binary expression with a memory location and non-location opera...
DefinedSVal getMetadataSymbolVal(const void *symbolTag, const MemRegion *region, const Expr *expr, QualType type, const LocationContext *LCtx, unsigned count)
MemRegionManager & getRegionManager()
Definition: SValBuilder.h:167
ProgramStateManager & getStateManager()
Definition: SValBuilder.h:151
SVal makeSymExprValNN(BinaryOperator::Opcode op, NonLoc lhs, NonLoc rhs, QualType resultTy)
Constructs a symbolic expression for two non-location values.
virtual SVal evalBinOpLL(ProgramStateRef state, BinaryOperator::Opcode op, Loc lhs, Loc rhs, QualType resultTy)=0
Create a new value which represents a binary expression with two memory location operands.
nonloc::SymbolVal makeNonLoc(const SymExpr *lhs, BinaryOperator::Opcode op, const llvm::APSInt &rhs, QualType type)
Definition: SValBuilder.cpp:77
const unsigned ArrayIndexWidth
The width of the scalar type used for array indices.
Definition: SValBuilder.h:76
DefinedSVal getBlockPointer(const BlockDecl *block, CanQualType locTy, const LocationContext *locContext, unsigned blockCount)
DefinedSVal getFunctionPointer(const FunctionDecl *func)
const QualType ArrayIndexTy
The scalar type to use for array indices.
Definition: SValBuilder.h:73
NonLoc makePointerToMember(const PointerToMemberData *PTMD)
Definition: SValBuilder.h:276
NonLoc makeIntValWithWidth(QualType ptrType, uint64_t integer)
Definition: SValBuilder.h:325
loc::GotoLabel makeLoc(const AddrLabelExpr *expr)
Definition: SValBuilder.h:385
NonLoc makeArrayIndex(uint64_t idx)
Definition: SValBuilder.h:284
ASTContext & getContext()
Definition: SValBuilder.h:148
nonloc::ConcreteInt makeIntVal(const IntegerLiteral *integer)
Definition: SValBuilder.h:290
SVal convertToArrayIndex(SVal val)
const SymbolConjured * conjureSymbol(const Expr *expr, const LocationContext *LCtx, unsigned visitCount, const void *symbolTag=nullptr)
Definition: SValBuilder.h:182
QualType getArrayIndexType() const
Definition: SValBuilder.h:157
loc::MemRegionVal makeLoc(SymbolRef sym)
Definition: SValBuilder.h:377
virtual const llvm::APSInt * getMinValue(ProgramStateRef state, SVal val)=0
Tries to get the minimal possible (integer) value of a given SVal.
const BasicValueFactory & getBasicValueFactory() const
Definition: SValBuilder.h:162
virtual SVal evalBinOpNN(ProgramStateRef state, BinaryOperator::Opcode op, NonLoc lhs, NonLoc rhs, QualType resultTy)=0
Create a new value which represents a binary expression with two non- location operands.
DefinedSVal makeSymbolVal(SymbolRef Sym)
Make an SVal that represents the given symbol.
Definition: SValBuilder.h:400
SVal evalCast(SVal V, QualType CastTy, QualType OriginalTy)
Cast a given SVal to another SVal using given QualType's.
NonLoc makeIntVal(uint64_t integer, bool isUnsigned)
Definition: SValBuilder.h:321
const AnalyzerOptions & getAnalyzerOptions() const
Definition: SValBuilder.h:170
nonloc::ConcreteInt makeTruthVal(bool b)
Definition: SValBuilder.h:354
DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag, const Expr *expr, const LocationContext *LCtx, unsigned count)
Create a new symbol with a unique 'name'.
DefinedSVal makeIntVal(uint64_t integer, QualType type)
Definition: SValBuilder.h:314
BasicValueFactory BasicVals
Manager of APSInt values.
Definition: SValBuilder.h:60
ConditionTruthVal areEqual(ProgramStateRef state, SVal lhs, SVal rhs)
virtual SVal simplifySVal(ProgramStateRef State, SVal Val)=0
Simplify symbolic expressions within a given SVal.
QualType getConditionType() const
Definition: SValBuilder.h:153
MemRegionManager MemMgr
Manages the creation of memory regions.
Definition: SValBuilder.h:66
SVal evalEQ(ProgramStateRef state, SVal lhs, SVal rhs)
SVal evalUnaryOp(ProgramStateRef state, UnaryOperator::Opcode opc, SVal operand, QualType type)
DefinedOrUnknownSVal getDerivedRegionValueSymbolVal(SymbolRef parentSymbol, const TypedValueRegion *region)
loc::MemRegionVal getCXXThis(const CXXMethodDecl *D, const StackFrameContext *SFC)
Return a memory region for the 'this' object reference.
nonloc::ConcreteInt makeTruthVal(bool b, QualType type)
Definition: SValBuilder.h:350
const MemRegionManager & getRegionManager() const
Definition: SValBuilder.h:168
virtual ~SValBuilder()=default
loc::ConcreteInt makeNullWithType(QualType type)
Create NULL pointer, with proper pointer bit-width for given address space.
Definition: SValBuilder.h:361
virtual const llvm::APSInt * getMaxValue(ProgramStateRef state, SVal val)=0
Tries to get the maximal possible (integer) value of a given SVal.
NonLoc makeIntVal(const llvm::APInt &integer, bool isUnsigned)
Definition: SValBuilder.h:310
ProgramStateManager & StateMgr
Definition: SValBuilder.h:68
loc::MemRegionVal makeLoc(const MemRegion *region)
Definition: SValBuilder.h:381
std::optional< SVal > getConstantVal(const Expr *E)
Returns the value of E, if it can be determined in a non-path-sensitive manner.
NonLoc makeLocAsInteger(Loc loc, unsigned bits)
Definition: SValBuilder.h:329
const ASTContext & getContext() const
Definition: SValBuilder.h:149
SVal evalIntegralCast(ProgramStateRef state, SVal val, QualType castTy, QualType originalType)
SymbolManager & getSymbolManager()
Definition: SValBuilder.h:164
DefinedOrUnknownSVal getRegionValueSymbolVal(const TypedValueRegion *region)
Make a unique symbol for value of region.
SVal evalBinOp(ProgramStateRef state, BinaryOperator::Opcode op, SVal lhs, SVal rhs, QualType type)
loc::ConcreteInt makeIntLocVal(const llvm::APSInt &integer)
Definition: SValBuilder.h:306
NonLoc makeLazyCompoundVal(const StoreRef &store, const TypedValueRegion *region)
Definition: SValBuilder.h:266
const AnalyzerOptions & AnOpts
Definition: SValBuilder.h:70
const SymbolManager & getSymbolManager() const
Definition: SValBuilder.h:165
std::optional< loc::MemRegionVal > getCastedMemRegionVal(const MemRegion *region, QualType type)
Return MemRegionVal on success cast, otherwise return std::nullopt.
loc::MemRegionVal getAllocaRegionVal(const Expr *E, const LocationContext *LCtx, unsigned Count)
Create an SVal representing the result of an alloca()-like call, that is, an AllocaRegion on the stac...
nonloc::ConcreteInt makeBoolVal(const ObjCBoolLiteralExpr *boolean)
Definition: SValBuilder.h:296
nonloc::ConcreteInt makeIntVal(const llvm::APSInt &integer)
Definition: SValBuilder.h:302
DefinedOrUnknownSVal getConjuredHeapSymbolVal(const Expr *E, const LocationContext *LCtx, unsigned Count)
Conjure a symbol representing heap allocated memory region.
SVal - This represents a symbolic expression, which can be either an L-value or an R-value.
Definition: SVals.h:55
Symbolic value.
Definition: SymExpr.h:30
virtual QualType getType() const =0
A symbol representing the result of an expression in the case when we do not know anything about what...
Definition: SymbolManager.h:79
const SymbolConjured * conjureSymbol(const Stmt *E, const LocationContext *LCtx, QualType T, unsigned VisitCount, const void *SymbolTag=nullptr)
TypedValueRegion - An abstract class representing regions having a typed value.
Definition: MemRegion.h:530
Value representing integer constant.
Definition: SVals.h:297
Value representing pointer-to-member.
Definition: SVals.h:382
Represents symbolic expression that isn't a location.
Definition: SVals.h:276
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Stmt > stmt
Matches statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
SValBuilder * createSimpleSValBuilder(llvm::BumpPtrAllocator &alloc, ASTContext &context, ProgramStateManager &stateMgr)
The JSON file list parser is used to communicate input to InstallAPI.
BinaryOperatorKind
UnaryOperatorKind