This is an archive of the discontinued LLVM Phabricator instance.

Differential D27365

[analyzer] Print type for SymbolRegionValues when dumping to stream
ClosedPublic

Authored by ddcc on Dec 2 2016, 2:40 PM.

Details

Reviewers
dcoughlin
zaks.anna
NoQ
Commits
rG0dd2306538e4: [analyzer] Print type for SymbolRegionValues when dumping to stream
rC288696: [analyzer] Print type for SymbolRegionValues when dumping to stream
rL288696: [analyzer] Print type for SymbolRegionValues when dumping to stream

Diff Detail

Event Timeline

ddcc updated this revision to Diff 80135.Dec 2 2016, 2:40 PM
ddcc retitled this revision from to [analyzer] Print type for SymbolRegionValues when dumping to stream.
ddcc updated this object.
ddcc added reviewers: NoQ, dcoughlin, zaks.anna.
ddcc added a subscriber: cfe-commits.
zaks.anna accepted this revision.Dec 2 2016, 6:13 PM
zaks.anna edited edge metadata.
This revision is now accepted and ready to land.Dec 2 2016, 6:13 PM
NoQ accepted this revision.Dec 2 2016, 11:28 PM
NoQ edited edge metadata.

Thanks, i love dumps! Btw, did you encounter cases when types are unobvious from the parent region?

lib/StaticAnalyzer/Core/SymbolManager.cpp
89

The rest of the code uses single-quotes for single characters, even though it's not really important here.

ddcc added a comment.Dec 3 2016, 11:43 AM

Yeah, I had to implement implicit type promotion and conversion, because Z3 checks expression types pretty strictly.

ddcc updated this revision to Diff 80309.Dec 5 2016, 12:36 PM
ddcc edited edge metadata.

Use single quotes

Herald added subscribers: mgorny, klimek. · View Herald TranscriptDec 5 2016, 12:36 PM
ddcc updated this revision to Diff 80310.Dec 5 2016, 12:39 PM

Fix rebase

Closed by commit rL288696: [analyzer] Print type for SymbolRegionValues when dumping to stream (authored by ddcc). · Explain WhyDec 5 2016, 12:40 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
bindings/
python/
tests/
cindex/
2 lines
2 lines
docs/
2 lines
3 lines
include/
clang-c/
21 lines
clang/
AST/
5 lines
Basic/
3 lines
11 lines
82 lines
CodeGen/
3 lines
Driver/
2 lines
Format/
9 lines
Sema/
5 lines
Tooling/
8 lines
8 lines
lib/
AST/
31 lines
1 line
18 lines
6 lines
Analysis/
12 lines
2 lines
3 lines
CodeGen/
2 lines
5 lines
30 lines
6 lines
30 lines
5 lines
21 lines
Driver/
2 lines
13 lines
29 lines
Format/
130 lines
Frontend/
2 lines
2 lines
Parse/
2 lines
6 lines
Sema/
12 lines
2 lines
7 lines
6 lines
45 lines
56 lines
11 lines
15 lines
12 lines
37 lines
42 lines
1 line
11 lines
10 lines
62 lines
StaticAnalyzer/
Checkers/
31 lines
Core/
10 lines
3 lines
Tooling/
3 lines
10 lines
test/
Analysis/
2 lines
2 lines
12410 lines
6 lines
CXX/
dcl.decl/
dcl.init/
dcl.init.aggr/
36 lines
2 lines
drs/
11 lines
47 lines
2 lines
20 lines
expr/
expr.const/
6 lines
CodeGenCXX/
24 lines
32 lines
7 lines
2 lines
2 lines
30 lines
18 lines
5 lines
21 lines
Driver/
1 line
5 lines
22 lines
Frontend/
12 lines
Index/
14 lines
Lexer/
3 lines
Misc/
4 lines
Sema/
2 lines
SemaCXX/
27 lines
2 lines
15 lines
2 lines
SemaObjC/
5 lines
tools/
c-index-test/
10 lines
clang-format-vs/
11 lines
9 lines
ClangFormat/
98 lines
22 lines
22 lines
clang-format/
2 lines
driver/
12 lines
libclang/
39 lines
3 lines
unittests/
ASTMatchers/
2 lines
Analysis/
68 lines
Format/
87 lines
Tooling/
8 lines
utils/
TableGen/
2 lines
10 lines
35 lines
www/
10 lines

Diff 80309

bindings/python/tests/cindex/test_cursor.py

Show First 20 Lines • Show All 369 Lines • ▼ Show 20 Linesdef test_result_type():
assert t.kind == TypeKind.INT assert t.kind == TypeKind.INT
def test_get_tokens(): def test_get_tokens():
"""Ensure we can map cursors back to tokens.""" """Ensure we can map cursors back to tokens."""
tu = get_tu('int foo(int i);') tu = get_tu('int foo(int i);')
foo = get_cursor(tu, 'foo') foo = get_cursor(tu, 'foo')
tokens = list(foo.get_tokens()) tokens = list(foo.get_tokens())
assert len(tokens) == 7 assert len(tokens) == 6
assert tokens[0].spelling == 'int' assert tokens[0].spelling == 'int'
assert tokens[1].spelling == 'foo' assert tokens[1].spelling == 'foo'
def test_get_arguments(): def test_get_arguments():
tu = get_tu('void foo(int i, int j);') tu = get_tu('void foo(int i, int j);')
foo = get_cursor(tu, 'foo') foo = get_cursor(tu, 'foo')
arguments = list(foo.get_arguments()) arguments = list(foo.get_arguments())
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

bindings/python/tests/cindex/test_tokens.py

from clang.cindex import CursorKind from clang.cindex import CursorKind
from clang.cindex import Index from clang.cindex import Index
from clang.cindex import SourceLocation from clang.cindex import SourceLocation
from clang.cindex import SourceRange from clang.cindex import SourceRange
from clang.cindex import TokenKind from clang.cindex import TokenKind
from nose.tools import eq_ from nose.tools import eq_
from nose.tools import ok_ from nose.tools import ok_
from .util import get_tu from .util import get_tu
def test_token_to_cursor(): def test_token_to_cursor():
"""Ensure we can obtain a Cursor from a Token instance.""" """Ensure we can obtain a Cursor from a Token instance."""
tu = get_tu('int i = 5;') tu = get_tu('int i = 5;')
r = tu.get_extent('t.c', (0, 9)) r = tu.get_extent('t.c', (0, 9))
tokens = list(tu.get_tokens(extent=r)) tokens = list(tu.get_tokens(extent=r))
assert len(tokens) == 5 assert len(tokens) == 4
assert tokens[1].spelling == 'i' assert tokens[1].spelling == 'i'
assert tokens[1].kind == TokenKind.IDENTIFIER assert tokens[1].kind == TokenKind.IDENTIFIER
cursor = tokens[1].cursor cursor = tokens[1].cursor
assert cursor.kind == CursorKind.VAR_DECL assert cursor.kind == CursorKind.VAR_DECL
assert tokens[1].cursor == tokens[2].cursor assert tokens[1].cursor == tokens[2].cursor
def test_token_location(): def test_token_location():
Show All 27 Lines

docs/ClangFormat.rst

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines optional arguments:
-regex PATTERN custom pattern selecting file paths to reformat -regex PATTERN custom pattern selecting file paths to reformat
-style STYLE formatting style to apply (LLVM, Google, Chromium, Mozilla, -style STYLE formatting style to apply (LLVM, Google, Chromium, Mozilla,
WebKit) WebKit)
So to reformat all the lines in the latest :program:`git` commit, just do: So to reformat all the lines in the latest :program:`git` commit, just do:
.. code-block:: console .. code-block:: console
git diff -U0 HEAD^ | clang-format-diff.py -i -p1 git diff -U0 --no-color HEAD^ | clang-format-diff.py -i -p1
In an SVN client, you can do: In an SVN client, you can do:
.. code-block:: console .. code-block:: console
svn diff --diff-cmd=diff -x -U0 | clang-format-diff.py -i svn diff --diff-cmd=diff -x -U0 | clang-format-diff.py -i
The option `-U0` will create a diff without context lines (the script would format The option `-U0` will create a diff without context lines (the script would format
those as well). those as well).

docs/JSONCompilationDatabase.rst

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
- **command:** The compile command executed. After JSON unescaping, - **command:** The compile command executed. After JSON unescaping,
this must be a valid command to rerun the exact compilation step for this must be a valid command to rerun the exact compilation step for
the translation unit in the environment the build system uses. the translation unit in the environment the build system uses.
Parameters use shell quoting and shell escaping of quotes, with '``"``' Parameters use shell quoting and shell escaping of quotes, with '``"``'
and '``\``' being the only special characters. Shell expansion is not and '``\``' being the only special characters. Shell expansion is not
supported. supported.
- **arguments:** The compile command executed as list of strings. - **arguments:** The compile command executed as list of strings.
Either **arguments** or **command** is required. Either **arguments** or **command** is required.
- **output:** The name of the output created by this compilation step.
This field is optional. It can be used to distinguish different processing
modes of the same input file.
Build System Integration Build System Integration
======================== ========================
The convention is to name the file compile\_commands.json and put it at The convention is to name the file compile\_commands.json and put it at
the top of the build directory. Clang tools are pointed to the top of the top of the build directory. Clang tools are pointed to the top of
the build directory to detect the file and use the compilation database the build directory to detect the file and use the compilation database
to parse C++ code in the source tree. to parse C++ code in the source tree.

include/clang-c/Index.h

Show All 26 Lines
* \brief The version constants for the libclang API. * \brief The version constants for the libclang API.
* CINDEX_VERSION_MINOR should increase when there are API additions. * CINDEX_VERSION_MINOR should increase when there are API additions.
* CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes. * CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
* *
* The policy about the libclang API was always to keep it source and ABI * The policy about the libclang API was always to keep it source and ABI
* compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable. * compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable.
*/ */
#define CINDEX_VERSION_MAJOR 0 #define CINDEX_VERSION_MAJOR 0
#define CINDEX_VERSION_MINOR 36 #define CINDEX_VERSION_MINOR 37
#define CINDEX_VERSION_ENCODE(major, minor) ( \ #define CINDEX_VERSION_ENCODE(major, minor) ( \
((major) * 10000) \ ((major) * 10000) \
+ ((minor) * 1)) + ((minor) * 1))
#define CINDEX_VERSION CINDEX_VERSION_ENCODE( \ #define CINDEX_VERSION CINDEX_VERSION_ENCODE( \
CINDEX_VERSION_MAJOR, \ CINDEX_VERSION_MAJOR, \
CINDEX_VERSION_MINOR ) CINDEX_VERSION_MINOR )
▲ Show 20 Lines • Show All 5,217 Lines • ▼ Show 20 Lines
/** /**
* \brief Returns the evaluation result as integer if the * \brief Returns the evaluation result as integer if the
* kind is Int. * kind is Int.
*/ */
CINDEX_LINKAGE int clang_EvalResult_getAsInt(CXEvalResult E); CINDEX_LINKAGE int clang_EvalResult_getAsInt(CXEvalResult E);
/** /**
* \brief Returns the evaluation result as a long long integer if the
* kind is Int. This prevents overflows that may happen if the result is
* returned with clang_EvalResult_getAsInt.
*/
CINDEX_LINKAGE long long clang_EvalResult_getAsLongLong(CXEvalResult E);
/**
* \brief Returns a non-zero value if the kind is Int and the evaluation
* result resulted in an unsigned integer.
*/
CINDEX_LINKAGE unsigned clang_EvalResult_isUnsignedInt(CXEvalResult E);
/**
* \brief Returns the evaluation result as an unsigned integer if
* the kind is Int and clang_EvalResult_isUnsignedInt is non-zero.
*/
CINDEX_LINKAGE unsigned long long clang_EvalResult_getAsUnsigned(CXEvalResult E);
/**
* \brief Returns the evaluation result as double if the * \brief Returns the evaluation result as double if the
* kind is double. * kind is double.
*/ */
CINDEX_LINKAGE double clang_EvalResult_getAsDouble(CXEvalResult E); CINDEX_LINKAGE double clang_EvalResult_getAsDouble(CXEvalResult E);
/** /**
* \brief Returns the evaluation result as a constant string if the * \brief Returns the evaluation result as a constant string if the
* kind is other than Int or float. User must not free this pointer, * kind is other than Int or float. User must not free this pointer,
▲ Show 20 Lines • Show All 765 Lines • Show Last 20 Lines

include/clang/AST/Expr.h

Show First 20 Lines • Show All 833 Lines • ▼ Show 20 Linespublic:
const Expr *getBestDynamicClassTypeExpr() const; const Expr *getBestDynamicClassTypeExpr() const;
/// Walk outwards from an expression we want to bind a reference to and /// Walk outwards from an expression we want to bind a reference to and
/// find the expression whose lifetime needs to be extended. Record /// find the expression whose lifetime needs to be extended. Record
/// the LHSs of comma expressions and adjustments needed along the path. /// the LHSs of comma expressions and adjustments needed along the path.
const Expr *skipRValueSubobjectAdjustments( const Expr *skipRValueSubobjectAdjustments(
SmallVectorImpl<const Expr *> &CommaLHS, SmallVectorImpl<const Expr *> &CommaLHS,
SmallVectorImpl<SubobjectAdjustment> &Adjustments) const; SmallVectorImpl<SubobjectAdjustment> &Adjustments) const;
const Expr *skipRValueSubobjectAdjustments() const {
SmallVector<const Expr *, 8> CommaLHSs;
SmallVector<SubobjectAdjustment, 8> Adjustments;
return skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
}
static bool classof(const Stmt *T) { static bool classof(const Stmt *T) {
return T->getStmtClass() >= firstExprConstant && return T->getStmtClass() >= firstExprConstant &&
T->getStmtClass() <= lastExprConstant; T->getStmtClass() <= lastExprConstant;
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 4,100 Lines • Show Last 20 Lines

include/clang/Basic/DiagnosticGroups.td

Show First 20 Lines • Show All 840 Lines • ▼ Show 20 Lines
def ObjCStringComparison : DiagGroup<"objc-string-compare">; def ObjCStringComparison : DiagGroup<"objc-string-compare">;
def ObjCStringConcatenation : DiagGroup<"objc-string-concatenation">; def ObjCStringConcatenation : DiagGroup<"objc-string-concatenation">;
def ObjCLiteralComparison : DiagGroup<"objc-literal-compare", [ def ObjCLiteralComparison : DiagGroup<"objc-literal-compare", [
ObjCStringComparison ObjCStringComparison
]>; ]>;
// Inline ASM warnings. // Inline ASM warnings.
def ASMOperandWidths : DiagGroup<"asm-operand-widths">; def ASMOperandWidths : DiagGroup<"asm-operand-widths">;
def ASMIgnoredQualifier : DiagGroup<"asm-ignored-qualifier">;
def ASM : DiagGroup<"asm", [ def ASM : DiagGroup<"asm", [
ASMOperandWidths ASMOperandWidths, ASMIgnoredQualifier
]>; ]>;
// OpenMP warnings. // OpenMP warnings.
def SourceUsesOpenMP : DiagGroup<"source-uses-openmp">; def SourceUsesOpenMP : DiagGroup<"source-uses-openmp">;
def OpenMPClauses : DiagGroup<"openmp-clauses">; def OpenMPClauses : DiagGroup<"openmp-clauses">;
def OpenMPLoopForm : DiagGroup<"openmp-loop-form">; def OpenMPLoopForm : DiagGroup<"openmp-loop-form">;
def OpenMPTarget : DiagGroup<"openmp-target">; def OpenMPTarget : DiagGroup<"openmp-target">;
Show All 36 Lines

include/clang/Basic/DiagnosticParseKinds.td

//==--- DiagnosticParseKinds.td - libparse diagnostics --------------------===// //==--- DiagnosticParseKinds.td - libparse diagnostics --------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Parser Diagnostics // Parser Diagnostics
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
let Component = "Parse" in { let Component = "Parse" in {
def w_asm_qualifier_ignored : Warning<"ignored %0 qualifier on asm">, def warn_asm_qualifier_ignored : Warning<
CatInlineAsm; "ignored %0 qualifier on asm">, CatInlineAsm, InGroup<ASMIgnoredQualifier>;
def warn_file_asm_volatile : Warning< def warn_file_asm_volatile : Warning<
"meaningless 'volatile' on asm outside function">, CatInlineAsm; "meaningless 'volatile' on asm outside function">, CatInlineAsm,
InGroup<ASMIgnoredQualifier>;
let CategoryName = "Inline Assembly Issue" in { let CategoryName = "Inline Assembly Issue" in {
def err_asm_empty : Error<"__asm used with no assembly instructions">; def err_asm_empty : Error<"__asm used with no assembly instructions">;
def err_inline_ms_asm_parsing : Error<"%0">; def err_inline_ms_asm_parsing : Error<"%0">;
def err_msasm_unsupported_arch : Error< def err_msasm_unsupported_arch : Error<
"Unsupported architecture '%0' for MS-style inline assembly">; "Unsupported architecture '%0' for MS-style inline assembly">;
def err_msasm_unable_to_create_target : Error< def err_msasm_unable_to_create_target : Error<
"MS-style inline assembly is not available: %0">; "MS-style inline assembly is not available: %0">;
Show All 30 Linesdef ext_keyword_as_ident : ExtWarn<
"keyword '%0' will be made available as an identifier " "keyword '%0' will be made available as an identifier "
"%select{here|for the remainder of the translation unit}1">, "%select{here|for the remainder of the translation unit}1">,
InGroup<KeywordCompat>; InGroup<KeywordCompat>;
def ext_nullability : Extension< def ext_nullability : Extension<
"type nullability specifier %0 is a Clang extension">, "type nullability specifier %0 is a Clang extension">,
InGroup<DiagGroup<"nullability-extension">>; InGroup<DiagGroup<"nullability-extension">>;
def error_empty_enum : Error<"use of empty enum">; def err_empty_enum : Error<"use of empty enum">;
def ext_ident_list_in_param : Extension< def ext_ident_list_in_param : Extension<
"type-less parameter names in function declaration">; "type-less parameter names in function declaration">;
def ext_c99_variable_decl_in_for_loop : Extension< def ext_c99_variable_decl_in_for_loop : Extension<
"variable declaration in for loop is a C99-specific feature">, InGroup<C99>; "variable declaration in for loop is a C99-specific feature">, InGroup<C99>;
def ext_c99_compound_literal : Extension< def ext_c99_compound_literal : Extension<
"compound literals are a C99-specific feature">, InGroup<C99>; "compound literals are a C99-specific feature">, InGroup<C99>;
def ext_enumerator_list_comma_c : Extension< def ext_enumerator_list_comma_c : Extension<
▲ Show 20 Lines • Show All 341 Lines • ▼ Show 20 Linesdef err_missing_catch_finally : Error<
"@try statement without a @catch and @finally clause">; "@try statement without a @catch and @finally clause">;
def err_objc_concat_string : Error<"unexpected token after Objective-C string">; def err_objc_concat_string : Error<"unexpected token after Objective-C string">;
def err_expected_objc_container : Error< def err_expected_objc_container : Error<
"'@end' must appear in an Objective-C context">; "'@end' must appear in an Objective-C context">;
def err_unexpected_protocol_qualifier : Error< def err_unexpected_protocol_qualifier : Error<
"@implementation declaration cannot be protocol qualified">; "@implementation declaration cannot be protocol qualified">;
def err_objc_unexpected_atend : Error< def err_objc_unexpected_atend : Error<
"'@end' appears where closing brace '}' is expected">; "'@end' appears where closing brace '}' is expected">;
def error_property_ivar_decl : Error<
"property synthesize requires specification of an ivar">;
def err_synthesized_property_name : Error< def err_synthesized_property_name : Error<
"expected a property name in @synthesize">; "expected a property name in @synthesize">;
def warn_semicolon_before_method_body : Warning< def warn_semicolon_before_method_body : Warning<
"semicolon before method body is ignored">, "semicolon before method body is ignored">,
InGroup<SemiBeforeMethodBody>, DefaultIgnore; InGroup<SemiBeforeMethodBody>, DefaultIgnore;
def note_extra_comma_message_arg : Note< def note_extra_comma_message_arg : Note<
"comma separating Objective-C messaging arguments">; "comma separating Objective-C messaging arguments">;
▲ Show 20 Lines • Show All 647 Lines • Show Last 20 Lines

include/clang/Basic/DiagnosticSemaKinds.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 900 Lines • ▼ Show 20 Lines
"NSCopying protocol is not appropriate with -fobjc-gc[-only]">; "NSCopying protocol is not appropriate with -fobjc-gc[-only]">;
def warn_multiple_method_decl : Warning<"multiple methods named %0 found">, def warn_multiple_method_decl : Warning<"multiple methods named %0 found">,
InGroup<ObjCMultipleMethodNames>; InGroup<ObjCMultipleMethodNames>;
def warn_strict_multiple_method_decl : Warning< def warn_strict_multiple_method_decl : Warning<
"multiple methods named %0 found">, InGroup<StrictSelector>, DefaultIgnore; "multiple methods named %0 found">, InGroup<StrictSelector>, DefaultIgnore;
def warn_accessor_property_type_mismatch : Warning< def warn_accessor_property_type_mismatch : Warning<
"type of property %0 does not match type of accessor %1">; "type of property %0 does not match type of accessor %1">;
def not_conv_function_declared_at : Note<"type conversion function declared here">; def note_conv_function_declared_at : Note<"type conversion function declared here">;
def note_method_declared_at : Note<"method %0 declared here">; def note_method_declared_at : Note<"method %0 declared here">;
def note_property_attribute : Note<"property %0 is declared " def note_property_attribute : Note<"property %0 is declared "
"%select{deprecated|unavailable|partial}1 here">; "%select{deprecated|unavailable|partial}1 here">;
def err_setter_type_void : Error<"type of setter must be void">; def err_setter_type_void : Error<"type of setter must be void">;
def err_duplicate_method_decl : Error<"duplicate declaration of method %0">; def err_duplicate_method_decl : Error<"duplicate declaration of method %0">;
def warn_duplicate_method_decl : def warn_duplicate_method_decl :
Warning<"multiple declarations of method %0 found and ignored">, Warning<"multiple declarations of method %0 found and ignored">,
InGroup<MethodDuplicate>, DefaultIgnore; InGroup<MethodDuplicate>, DefaultIgnore;
def warn_objc_cdirective_format_string : def warn_objc_cdirective_format_string :
Warning<"using %0 directive in %select{NSString|CFString}1 " Warning<"using %0 directive in %select{NSString|CFString}1 "
"which is being passed as a formatting argument to the formatting " "which is being passed as a formatting argument to the formatting "
"%select{method|CFfunction}2">, "%select{method|CFfunction}2">,
InGroup<ObjCCStringFormat>, DefaultIgnore; InGroup<ObjCCStringFormat>, DefaultIgnore;
def err_objc_var_decl_inclass : def err_objc_var_decl_inclass :
Error<"cannot declare variable inside @interface or @protocol">; Error<"cannot declare variable inside @interface or @protocol">;
def error_missing_method_context : Error< def err_missing_method_context : Error<
"missing context for method declaration">; "missing context for method declaration">;
def err_objc_property_attr_mutually_exclusive : Error< def err_objc_property_attr_mutually_exclusive : Error<
"property attributes '%0' and '%1' are mutually exclusive">; "property attributes '%0' and '%1' are mutually exclusive">;
def err_objc_property_requires_object : Error< def err_objc_property_requires_object : Error<
"property with '%0' attribute must be of object type">; "property with '%0' attribute must be of object type">;
def warn_objc_property_no_assignment_attribute : Warning< def warn_objc_property_no_assignment_attribute : Warning<
"no 'assign', 'retain', or 'copy' attribute is specified - " "no 'assign', 'retain', or 'copy' attribute is specified - "
"'assign' is assumed">, "'assign' is assumed">,
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Linesdef warn_missing_explicit_synthesis : Warning <
"auto property synthesis is synthesizing property not explicitly synthesized">, "auto property synthesis is synthesizing property not explicitly synthesized">,
InGroup<DiagGroup<"objc-missing-property-synthesis">>, DefaultIgnore; InGroup<DiagGroup<"objc-missing-property-synthesis">>, DefaultIgnore;
def warn_property_getter_owning_mismatch : Warning< def warn_property_getter_owning_mismatch : Warning<
"property declared as returning non-retained objects" "property declared as returning non-retained objects"
"; getter returning retained objects">; "; getter returning retained objects">;
def warn_property_redecl_getter_mismatch : Warning< def warn_property_redecl_getter_mismatch : Warning<
"getter name mismatch between property redeclaration (%1) and its original " "getter name mismatch between property redeclaration (%1) and its original "
"declaration (%0)">, InGroup<PropertyAttr>; "declaration (%0)">, InGroup<PropertyAttr>;
def error_property_setter_ambiguous_use : Error< def err_property_setter_ambiguous_use : Error<
"synthesized properties %0 and %1 both claim setter %2 -" "synthesized properties %0 and %1 both claim setter %2 -"
" use of this setter will cause unexpected behavior">; " use of this setter will cause unexpected behavior">;
def warn_default_atomic_custom_getter_setter : Warning< def warn_default_atomic_custom_getter_setter : Warning<
"atomic by default property %0 has a user defined %select{getter|setter}1 " "atomic by default property %0 has a user defined %select{getter|setter}1 "
"(property should be marked 'atomic' if this is intended)">, "(property should be marked 'atomic' if this is intended)">,
InGroup<CustomAtomic>, DefaultIgnore; InGroup<CustomAtomic>, DefaultIgnore;
def err_use_continuation_class : Error< def err_use_continuation_class : Error<
"illegal redeclaration of property in class extension %0" "illegal redeclaration of property in class extension %0"
" (attribute must be 'readwrite', while its primary must be 'readonly')">; " (attribute must be 'readwrite', while its primary must be 'readonly')">;
def err_type_mismatch_continuation_class : Error< def err_type_mismatch_continuation_class : Error<
"type of property %0 in class extension does not match " "type of property %0 in class extension does not match "
"property type in primary class">; "property type in primary class">;
def err_use_continuation_class_redeclaration_readwrite : Error< def err_use_continuation_class_redeclaration_readwrite : Error<
"illegal redeclaration of 'readwrite' property in class extension %0" "illegal redeclaration of 'readwrite' property in class extension %0"
" (perhaps you intended this to be a 'readwrite' redeclaration of a " " (perhaps you intended this to be a 'readwrite' redeclaration of a "
"'readonly' public property?)">; "'readonly' public property?)">;
def err_continuation_class : Error<"class extension has no primary class">; def err_continuation_class : Error<"class extension has no primary class">;
def err_property_type : Error<"property cannot have array or function type %0">; def err_property_type : Error<"property cannot have array or function type %0">;
def error_missing_property_context : Error< def err_missing_property_context : Error<
"missing context for property implementation declaration">; "missing context for property implementation declaration">;
def error_bad_property_decl : Error< def err_bad_property_decl : Error<
"property implementation must have its declaration in interface %0 or one of " "property implementation must have its declaration in interface %0 or one of "
"its extensions">; "its extensions">;
def error_category_property : Error< def err_category_property : Error<
"property declared in category %0 cannot be implemented in " "property declared in category %0 cannot be implemented in "
"class implementation">; "class implementation">;
def note_property_declare : Note< def note_property_declare : Note<
"property declared here">; "property declared here">;
def note_protocol_property_declare : Note< def note_protocol_property_declare : Note<
"it could also be property of type %0 declared here">; "it could also be property of type %0 declared here">;
def note_property_synthesize : Note< def note_property_synthesize : Note<
"property synthesized here">; "property synthesized here">;
def error_synthesize_category_decl : Error< def err_synthesize_category_decl : Error<
"@synthesize not allowed in a category's implementation">; "@synthesize not allowed in a category's implementation">;
def error_synthesize_on_class_property : Error< def err_synthesize_on_class_property : Error<
"@synthesize not allowed on a class property %0">; "@synthesize not allowed on a class property %0">;
def error_reference_property : Error< def err_missing_property_interface : Error<
"property of reference type is not supported">;
def error_missing_property_interface : Error<
"property implementation in a category with no category declaration">; "property implementation in a category with no category declaration">;
def error_bad_category_property_decl : Error< def err_bad_category_property_decl : Error<
"property implementation must have its declaration in the category %0">; "property implementation must have its declaration in the category %0">;
def error_bad_property_context : Error< def err_bad_property_context : Error<
"property implementation must be in a class or category implementation">; "property implementation must be in a class or category implementation">;
def error_missing_property_ivar_decl : Error< def err_missing_property_ivar_decl : Error<
"synthesized property %0 must either be named the same as a compatible" "synthesized property %0 must either be named the same as a compatible"
" instance variable or must explicitly name an instance variable">; " instance variable or must explicitly name an instance variable">;
def err_arc_perform_selector_retains : Error< def err_arc_perform_selector_retains : Error<
"performSelector names a selector which retains the object">; "performSelector names a selector which retains the object">;
def warn_arc_perform_selector_leaks : Warning< def warn_arc_perform_selector_leaks : Warning<
"performSelector may cause a leak because its selector is unknown">, "performSelector may cause a leak because its selector is unknown">,
InGroup<DiagGroup<"arc-performSelector-leaks">>; InGroup<DiagGroup<"arc-performSelector-leaks">>;
def warn_dealloc_in_category : Warning< def warn_dealloc_in_category : Warning<
Show All 17 Linesdef warn_arc_possible_repeated_use_of_weak : Warning <
"and may be unpredictably set to nil; assign to a strong variable to keep " "and may be unpredictably set to nil; assign to a strong variable to keep "
"the object alive">, "the object alive">,
InGroup<ARCRepeatedUseOfWeakMaybe>, DefaultIgnore; InGroup<ARCRepeatedUseOfWeakMaybe>, DefaultIgnore;
def note_arc_weak_also_accessed_here : Note< def note_arc_weak_also_accessed_here : Note<
"also accessed here">; "also accessed here">;
def err_incomplete_synthesized_property : Error< def err_incomplete_synthesized_property : Error<
"cannot synthesize property %0 with incomplete type %1">; "cannot synthesize property %0 with incomplete type %1">;
def error_property_ivar_type : Error< def err_property_ivar_type : Error<
"type of property %0 (%1) does not match type of instance variable %2 (%3)">; "type of property %0 (%1) does not match type of instance variable %2 (%3)">;
def error_property_accessor_type : Error< def err_property_accessor_type : Error<
"type of property %0 (%1) does not match type of accessor %2 (%3)">; "type of property %0 (%1) does not match type of accessor %2 (%3)">;
def error_ivar_in_superclass_use : Error< def err_ivar_in_superclass_use : Error<
"property %0 attempting to use instance variable %1 declared in super class %2">; "property %0 attempting to use instance variable %1 declared in super class %2">;
def error_weak_property : Error< def err_weak_property : Error<
"existing instance variable %1 for __weak property %0 must be __weak">; "existing instance variable %1 for __weak property %0 must be __weak">;
def error_strong_property : Error< def err_strong_property : Error<
"existing instance variable %1 for strong property %0 may not be __weak">; "existing instance variable %1 for strong property %0 may not be __weak">;
def error_dynamic_property_ivar_decl : Error< def err_dynamic_property_ivar_decl : Error<
"dynamic property cannot have instance variable specification">; "dynamic property cannot have instance variable specification">;
def error_duplicate_ivar_use : Error< def err_duplicate_ivar_use : Error<
"synthesized properties %0 and %1 both claim instance variable %2">; "synthesized properties %0 and %1 both claim instance variable %2">;
def error_property_implemented : Error<"property %0 is already implemented">; def err_property_implemented : Error<"property %0 is already implemented">;
def warn_objc_missing_super_call : Warning< def warn_objc_missing_super_call : Warning<
"method possibly missing a [super %0] call">, "method possibly missing a [super %0] call">,
InGroup<ObjCMissingSuperCalls>; InGroup<ObjCMissingSuperCalls>;
def error_dealloc_bad_result_type : Error< def err_dealloc_bad_result_type : Error<
"dealloc return type must be correctly specified as 'void' under ARC, " "dealloc return type must be correctly specified as 'void' under ARC, "
"instead of %0">; "instead of %0">;
def warn_undeclared_selector : Warning< def warn_undeclared_selector : Warning<
"undeclared selector %0">, InGroup<UndeclaredSelector>, DefaultIgnore; "undeclared selector %0">, InGroup<UndeclaredSelector>, DefaultIgnore;
def warn_undeclared_selector_with_typo : Warning< def warn_undeclared_selector_with_typo : Warning<
"undeclared selector %0; did you mean %1?">, "undeclared selector %0; did you mean %1?">,
InGroup<UndeclaredSelector>, DefaultIgnore; InGroup<UndeclaredSelector>, DefaultIgnore;
def warn_implicit_atomic_property : Warning< def warn_implicit_atomic_property : Warning<
"property is assumed atomic by default">, InGroup<ImplicitAtomic>, DefaultIgnore; "property is assumed atomic by default">, InGroup<ImplicitAtomic>, DefaultIgnore;
def note_auto_readonly_iboutlet_fixup_suggest : Note< def note_auto_readonly_iboutlet_fixup_suggest : Note<
"property should be changed to be readwrite">; "property should be changed to be readwrite">;
def warn_auto_readonly_iboutlet_property : Warning< def warn_auto_readonly_iboutlet_property : Warning<
"readonly IBOutlet property %0 when auto-synthesized may " "readonly IBOutlet property %0 when auto-synthesized may "
"not work correctly with 'nib' loader">, "not work correctly with 'nib' loader">,
InGroup<DiagGroup<"readonly-iboutlet-property">>; InGroup<DiagGroup<"readonly-iboutlet-property">>;
def warn_auto_implicit_atomic_property : Warning< def warn_auto_implicit_atomic_property : Warning<
"property is assumed atomic when auto-synthesizing the property">, "property is assumed atomic when auto-synthesizing the property">,
InGroup<ImplicitAtomic>, DefaultIgnore; InGroup<ImplicitAtomic>, DefaultIgnore;
def warn_unimplemented_selector: Warning< def warn_unimplemented_selector: Warning<
"no method with selector %0 is implemented in this translation unit">, "no method with selector %0 is implemented in this translation unit">,
InGroup<Selector>, DefaultIgnore; InGroup<Selector>, DefaultIgnore;
def warn_unimplemented_protocol_method : Warning< def warn_unimplemented_protocol_method : Warning<
"method %0 in protocol %1 not implemented">, InGroup<Protocol>; "method %0 in protocol %1 not implemented">, InGroup<Protocol>;
def warning_multiple_selectors: Warning< def warn_multiple_selectors: Warning<
"several methods with selector %0 of mismatched types are found " "several methods with selector %0 of mismatched types are found "
"for the @selector expression">, "for the @selector expression">,
InGroup<SelectorTypeMismatch>, DefaultIgnore; InGroup<SelectorTypeMismatch>, DefaultIgnore;
def err_objc_kindof_nonobject : Error< def err_objc_kindof_nonobject : Error<
"'__kindof' specifier cannot be applied to non-object type %0">; "'__kindof' specifier cannot be applied to non-object type %0">;
def err_objc_kindof_wrong_position : Error< def err_objc_kindof_wrong_position : Error<
"'__kindof' type specifier must precede the declarator">; "'__kindof' type specifier must precede the declarator">;
▲ Show 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
def ext_incomplete_in_exception_spec : ExtWarn<err_incomplete_in_exception_spec.Text>, def ext_incomplete_in_exception_spec : ExtWarn<err_incomplete_in_exception_spec.Text>,
InGroup<MicrosoftExceptionSpec>; InGroup<MicrosoftExceptionSpec>;
def err_rref_in_exception_spec : Error< def err_rref_in_exception_spec : Error<
"rvalue reference type %0 is not allowed in exception specification">; "rvalue reference type %0 is not allowed in exception specification">;
def err_mismatched_exception_spec : Error< def err_mismatched_exception_spec : Error<
"exception specification in declaration does not match previous declaration">; "exception specification in declaration does not match previous declaration">;
def ext_mismatched_exception_spec : ExtWarn<err_mismatched_exception_spec.Text>, def ext_mismatched_exception_spec : ExtWarn<err_mismatched_exception_spec.Text>,
InGroup<MicrosoftExceptionSpec>; InGroup<MicrosoftExceptionSpec>;
def warn_mismatched_exception_spec_no_exceptions : ExtWarn<err_mismatched_exception_spec.Text>,
InGroup<DiagGroup<"exception-spec-no-exceptions">>;
def err_override_exception_spec : Error< def err_override_exception_spec : Error<
"exception specification of overriding function is more lax than " "exception specification of overriding function is more lax than "
"base version">; "base version">;
def ext_override_exception_spec : ExtWarn<err_override_exception_spec.Text>, def ext_override_exception_spec : ExtWarn<err_override_exception_spec.Text>,
InGroup<MicrosoftExceptionSpec>; InGroup<MicrosoftExceptionSpec>;
def err_incompatible_exception_specs : Error< def err_incompatible_exception_specs : Error<
"target exception specification is not superset of source">; "target exception specification is not superset of source">;
def warn_incompatible_exception_specs : Warning< def warn_incompatible_exception_specs : Warning<
▲ Show 20 Lines • Show All 1,124 Lines • ▼ Show 20 Linesdef warn_mismatched_section : Warning<
"section does not match previous declaration">, InGroup<Section>; "section does not match previous declaration">, InGroup<Section>;
def err_anonymous_property: Error< def err_anonymous_property: Error<
"anonymous property is not supported">; "anonymous property is not supported">;
def err_property_is_variably_modified : Error< def err_property_is_variably_modified : Error<
"property %0 has a variably modified type">; "property %0 has a variably modified type">;
def err_no_accessor_for_property : Error< def err_no_accessor_for_property : Error<
"no %select{getter|setter}0 defined for property %1">; "no %select{getter|setter}0 defined for property %1">;
def error_cannot_find_suitable_accessor : Error< def err_cannot_find_suitable_accessor : Error<
"cannot find suitable %select{getter|setter}0 for property %1">; "cannot find suitable %select{getter|setter}0 for property %1">;
def warn_alloca_align_alignof : Warning< def warn_alloca_align_alignof : Warning<
"second argument to __builtin_alloca_with_align is supposed to be in bits">, "second argument to __builtin_alloca_with_align is supposed to be in bits">,
InGroup<DiagGroup<"alloca-with-align-alignof">>; InGroup<DiagGroup<"alloca-with-align-alignof">>;
def err_alignment_too_small : Error< def err_alignment_too_small : Error<
"requested alignment must be %0 or greater">; "requested alignment must be %0 or greater">;
▲ Show 20 Lines • Show All 2,908 Lines • ▼ Show 20 Lines
def err_dereference_incomplete_type : Error< def err_dereference_incomplete_type : Error<
"dereference of pointer to incomplete type %0">; "dereference of pointer to incomplete type %0">;
def ext_gnu_subscript_void_type : Extension< def ext_gnu_subscript_void_type : Extension<
"subscript of a pointer to void is a GNU extension">, InGroup<PointerArith>; "subscript of a pointer to void is a GNU extension">, InGroup<PointerArith>;
def err_typecheck_member_reference_struct_union : Error< def err_typecheck_member_reference_struct_union : Error<
"member reference base type %0 is not a structure or union">; "member reference base type %0 is not a structure or union">;
def err_typecheck_member_reference_ivar : Error< def err_typecheck_member_reference_ivar : Error<
"%0 does not have a member named %1">; "%0 does not have a member named %1">;
def error_arc_weak_ivar_access : Error< def err_arc_weak_ivar_access : Error<
"dereferencing a __weak pointer is not allowed due to possible " "dereferencing a __weak pointer is not allowed due to possible "
"null value caused by race condition, assign it to strong variable first">; "null value caused by race condition, assign it to strong variable first">;
def err_typecheck_member_reference_arrow : Error< def err_typecheck_member_reference_arrow : Error<
"member reference type %0 is not a pointer">; "member reference type %0 is not a pointer">;
def err_typecheck_member_reference_suggestion : Error< def err_typecheck_member_reference_suggestion : Error<
"member reference type %0 is %select{a|not a}1 pointer; did you mean to use '%select{->|.}1'?">; "member reference type %0 is %select{a|not a}1 pointer; did you mean to use '%select{->|.}1'?">;
def note_typecheck_member_reference_suggestion : Note< def note_typecheck_member_reference_suggestion : Note<
"did you mean to use '.' instead?">; "did you mean to use '.' instead?">;
▲ Show 20 Lines • Show All 385 Lines • ▼ Show 20 Linesdef err_duplicate_property : Error<
"property has a previous declaration">; "property has a previous declaration">;
def ext_gnu_void_ptr : Extension< def ext_gnu_void_ptr : Extension<
"arithmetic on%select{ a|}0 pointer%select{|s}0 to void is a GNU extension">, "arithmetic on%select{ a|}0 pointer%select{|s}0 to void is a GNU extension">,
InGroup<PointerArith>; InGroup<PointerArith>;
def ext_gnu_ptr_func_arith : Extension< def ext_gnu_ptr_func_arith : Extension<
"arithmetic on%select{ a|}0 pointer%select{|s}0 to%select{ the|}2 function " "arithmetic on%select{ a|}0 pointer%select{|s}0 to%select{ the|}2 function "
"type%select{|s}2 %1%select{| and %3}2 is a GNU extension">, "type%select{|s}2 %1%select{| and %3}2 is a GNU extension">,
InGroup<PointerArith>; InGroup<PointerArith>;
def error_readonly_message_assignment : Error< def err_readonly_message_assignment : Error<
"assigning to 'readonly' return result of an Objective-C message not allowed">; "assigning to 'readonly' return result of an Objective-C message not allowed">;
def ext_integer_increment_complex : Extension< def ext_integer_increment_complex : Extension<
"ISO C does not support '++'/'--' on complex integer type %0">; "ISO C does not support '++'/'--' on complex integer type %0">;
def ext_integer_complement_complex : Extension< def ext_integer_complement_complex : Extension<
"ISO C does not support '~' for complex conjugation of %0">; "ISO C does not support '~' for complex conjugation of %0">;
def err_nosetter_property_assignment : Error< def err_nosetter_property_assignment : Error<
"%select{assignment to readonly property|" "%select{assignment to readonly property|"
"no setter method %1 for assignment to property}0">; "no setter method %1 for assignment to property}0">;
def err_nosetter_property_incdec : Error< def err_nosetter_property_incdec : Error<
"%select{%select{increment|decrement}1 of readonly property|" "%select{%select{increment|decrement}1 of readonly property|"
"no setter method %2 for %select{increment|decrement}1 of property}0">; "no setter method %2 for %select{increment|decrement}1 of property}0">;
def err_nogetter_property_compound_assignment : Error< def err_nogetter_property_compound_assignment : Error<
"a getter method is needed to perform a compound assignment on a property">; "a getter method is needed to perform a compound assignment on a property">;
def err_nogetter_property_incdec : Error< def err_nogetter_property_incdec : Error<
"no getter method %1 for %select{increment|decrement}0 of property">; "no getter method %1 for %select{increment|decrement}0 of property">;
def error_no_subobject_property_setting : Error< def err_no_subobject_property_setting : Error<
"expression is not assignable">; "expression is not assignable">;
def err_qualified_objc_access : Error< def err_qualified_objc_access : Error<
"%select{property|instance variable}0 access cannot be qualified with '%1'">; "%select{property|instance variable}0 access cannot be qualified with '%1'">;
def ext_freestanding_complex : Extension< def ext_freestanding_complex : Extension<
"complex numbers are an extension in a freestanding C99 implementation">; "complex numbers are an extension in a freestanding C99 implementation">;
// FIXME: Remove when we support imaginary. // FIXME: Remove when we support imaginary.
Show All 13 Linesdef warn_inst_method_not_found : Warning<
"instance method %objcinstance0 not found (return type defaults to 'id')">, "instance method %objcinstance0 not found (return type defaults to 'id')">,
InGroup<MethodAccess>; InGroup<MethodAccess>;
def warn_instance_method_not_found_with_typo : Warning< def warn_instance_method_not_found_with_typo : Warning<
"instance method %objcinstance0 not found (return type defaults to 'id')" "instance method %objcinstance0 not found (return type defaults to 'id')"
"; did you mean %objcinstance2?">, InGroup<MethodAccess>; "; did you mean %objcinstance2?">, InGroup<MethodAccess>;
def warn_class_method_not_found_with_typo : Warning< def warn_class_method_not_found_with_typo : Warning<
"class method %objcclass0 not found (return type defaults to 'id')" "class method %objcclass0 not found (return type defaults to 'id')"
"; did you mean %objcclass2?">, InGroup<MethodAccess>; "; did you mean %objcclass2?">, InGroup<MethodAccess>;
def error_method_not_found_with_typo : Error< def err_method_not_found_with_typo : Error<
"%select{instance|class}1 method %0 not found " "%select{instance|class}1 method %0 not found "
"; did you mean %2?">; "; did you mean %2?">;
def error_no_super_class_message : Error< def err_no_super_class_message : Error<
"no @interface declaration found in class messaging of %0">; "no @interface declaration found in class messaging of %0">;
def error_root_class_cannot_use_super : Error< def err_root_class_cannot_use_super : Error<
"%0 cannot use 'super' because it is a root class">; "%0 cannot use 'super' because it is a root class">;
def err_invalid_receiver_to_message_super : Error< def err_invalid_receiver_to_message_super : Error<
"'super' is only valid in a method body">; "'super' is only valid in a method body">;
def err_invalid_receiver_class_message : Error< def err_invalid_receiver_class_message : Error<
"receiver type %0 is not an Objective-C class">; "receiver type %0 is not an Objective-C class">;
def err_missing_open_square_message_send : Error< def err_missing_open_square_message_send : Error<
"missing '[' at start of message send expression">; "missing '[' at start of message send expression">;
def warn_bad_receiver_type : Warning< def warn_bad_receiver_type : Warning<
"receiver type %0 is not 'id' or interface pointer, consider " "receiver type %0 is not 'id' or interface pointer, consider "
"casting it to 'id'">,InGroup<ObjCReceiver>; "casting it to 'id'">,InGroup<ObjCReceiver>;
def err_bad_receiver_type : Error<"bad receiver type %0">; def err_bad_receiver_type : Error<"bad receiver type %0">;
def err_incomplete_receiver_type : Error<"incomplete receiver type %0">; def err_incomplete_receiver_type : Error<"incomplete receiver type %0">;
def err_unknown_receiver_suggest : Error< def err_unknown_receiver_suggest : Error<
"unknown receiver %0; did you mean %1?">; "unknown receiver %0; did you mean %1?">;
def error_objc_throw_expects_object : Error< def err_objc_throw_expects_object : Error<
"@throw requires an Objective-C object type (%0 invalid)">; "@throw requires an Objective-C object type (%0 invalid)">;
def error_objc_synchronized_expects_object : Error< def err_objc_synchronized_expects_object : Error<
"@synchronized requires an Objective-C object type (%0 invalid)">; "@synchronized requires an Objective-C object type (%0 invalid)">;
def error_rethrow_used_outside_catch : Error< def err_rethrow_used_outside_catch : Error<
"@throw (rethrow) used outside of a @catch block">; "@throw (rethrow) used outside of a @catch block">;
def err_attribute_multiple_objc_gc : Error< def err_attribute_multiple_objc_gc : Error<
"multiple garbage collection attributes specified for type">; "multiple garbage collection attributes specified for type">;
def err_catch_param_not_objc_type : Error< def err_catch_param_not_objc_type : Error<
"@catch parameter is not a pointer to an interface type">; "@catch parameter is not a pointer to an interface type">;
def err_illegal_qualifiers_on_catch_parm : Error< def err_illegal_qualifiers_on_catch_parm : Error<
"illegal qualifiers on @catch parameter">; "illegal qualifiers on @catch parameter">;
def err_storage_spec_on_catch_parm : Error< def err_storage_spec_on_catch_parm : Error<
▲ Show 20 Lines • Show All 547 Lines • ▼ Show 20 Linesdef err_typecheck_convert_incompatible : Error<
"%select{none|const|restrict|const and restrict|volatile|const and volatile|" "%select{none|const|restrict|const and restrict|volatile|const and volatile|"
"volatile and restrict|const, volatile, and restrict}6)" "volatile and restrict|const, volatile, and restrict}6)"
"|: different exception specifications}4">; "|: different exception specifications}4">;
def err_typecheck_missing_return_type_incompatible : Error< def err_typecheck_missing_return_type_incompatible : Error<
"%diff{return type $ must match previous return type $|" "%diff{return type $ must match previous return type $|"
"return type must match previous return type}0,1 when %select{block " "return type must match previous return type}0,1 when %select{block "
"literal|lambda expression}2 has unspecified explicit return type">; "literal|lambda expression}2 has unspecified explicit return type">;
def not_incomplete_class_and_qualified_id : Note< def note_incomplete_class_and_qualified_id : Note<
"conformance of forward class %0 to protocol %1 can not be confirmed">; "conformance of forward class %0 to protocol %1 can not be confirmed">;
def warn_incompatible_qualified_id : Warning< def warn_incompatible_qualified_id : Warning<
"%select{%diff{assigning to $ from incompatible type $|" "%select{%diff{assigning to $ from incompatible type $|"
"assigning to type from incompatible type}0,1" "assigning to type from incompatible type}0,1"
"|%diff{passing $ to parameter of incompatible type $|" "|%diff{passing $ to parameter of incompatible type $|"
"passing type to parameter of incompatible type}0,1" "passing type to parameter of incompatible type}0,1"
"|%diff{returning $ from a function with incompatible result type $|" "|%diff{returning $ from a function with incompatible result type $|"
"returning type from a function with incompatible result type}0,1" "returning type from a function with incompatible result type}0,1"
▲ Show 20 Lines • Show All 1,515 Lines • ▼ Show 20 Linesdef warn_ivar_use_hidden : Warning<
InGroup<ShadowIvar>; InGroup<ShadowIvar>;
def warn_direct_initialize_call : Warning< def warn_direct_initialize_call : Warning<
"explicit call to +initialize results in duplicate call to +initialize">, "explicit call to +initialize results in duplicate call to +initialize">,
InGroup<ExplicitInitializeCall>; InGroup<ExplicitInitializeCall>;
def warn_direct_super_initialize_call : Warning< def warn_direct_super_initialize_call : Warning<
"explicit call to [super initialize] should only be in implementation " "explicit call to [super initialize] should only be in implementation "
"of +initialize">, "of +initialize">,
InGroup<ExplicitInitializeCall>; InGroup<ExplicitInitializeCall>;
def error_ivar_use_in_class_method : Error< def err_ivar_use_in_class_method : Error<
"instance variable %0 accessed in class method">; "instance variable %0 accessed in class method">;
def error_implicit_ivar_access : Error< def err_private_ivar_access : Error<"instance variable %0 is private">,
"instance variable %0 cannot be accessed because 'self' has been redeclared">;
def error_private_ivar_access : Error<"instance variable %0 is private">,
AccessControl; AccessControl;
def error_protected_ivar_access : Error<"instance variable %0 is protected">, def err_protected_ivar_access : Error<"instance variable %0 is protected">,
AccessControl; AccessControl;
def warn_maynot_respond : Warning<"%0 may not respond to %1">; def warn_maynot_respond : Warning<"%0 may not respond to %1">;
def ext_typecheck_base_super : Warning< def ext_typecheck_base_super : Warning<
"method parameter type " "method parameter type "
"%diff{$ does not match super class method parameter type $|" "%diff{$ does not match super class method parameter type $|"
"does not match super class method parameter type}0,1">, "does not match super class method parameter type}0,1">,
InGroup<SuperSubClassMismatch>, DefaultIgnore; InGroup<SuperSubClassMismatch>, DefaultIgnore;
def warn_missing_method_return_type : Warning< def warn_missing_method_return_type : Warning<
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines
def err_sampler_initializer_not_integer : Error< def err_sampler_initializer_not_integer : Error<
"sampler_t initialization requires 32-bit integer, not %0">; "sampler_t initialization requires 32-bit integer, not %0">;
def warn_sampler_initializer_invalid_bits : Warning< def warn_sampler_initializer_invalid_bits : Warning<
"sampler initializer has invalid %0 bits">, InGroup<SpirCompat>, DefaultIgnore; "sampler initializer has invalid %0 bits">, InGroup<SpirCompat>, DefaultIgnore;
def err_sampler_argument_required : Error< def err_sampler_argument_required : Error<
"sampler_t variable required - got %0">; "sampler_t variable required - got %0">;
def err_wrong_sampler_addressspace: Error< def err_wrong_sampler_addressspace: Error<
"sampler type cannot be used with the __local and __global address space qualifiers">; "sampler type cannot be used with the __local and __global address space qualifiers">;
def error_opencl_cast_non_zero_to_event_t : Error< def err_opencl_cast_non_zero_to_event_t : Error<
"cannot cast non-zero value '%0' to 'event_t'">; "cannot cast non-zero value '%0' to 'event_t'">;
def err_opencl_global_invalid_addr_space : Error< def err_opencl_global_invalid_addr_space : Error<
"%select{program scope|static local|extern}0 variable must reside in %1 address space">; "%select{program scope|static local|extern}0 variable must reside in %1 address space">;
def err_missing_actual_pipe_type : Error< def err_missing_actual_pipe_type : Error<
"missing actual type specifier for pipe">; "missing actual type specifier for pipe">;
def err_reference_pipe_type : Error < def err_reference_pipe_type : Error <
"pipes packet types cannot be of reference type">; "pipes packet types cannot be of reference type">;
def err_opencl_no_main : Error<"%select{function|kernel}0 cannot be called 'main'">; def err_opencl_no_main : Error<"%select{function|kernel}0 cannot be called 'main'">;
▲ Show 20 Lines • Show All 447 Lines • ▼ Show 20 Lines
def err_omp_param_or_this_in_clause : Error< def err_omp_param_or_this_in_clause : Error<
"expected reference to one of the parameters of function %0%select{| or 'this'}1">; "expected reference to one of the parameters of function %0%select{| or 'this'}1">;
def err_omp_expected_uniform_param : Error< def err_omp_expected_uniform_param : Error<
"expected a reference to a parameter specified in a 'uniform' clause">; "expected a reference to a parameter specified in a 'uniform' clause">;
def err_omp_expected_int_param : Error< def err_omp_expected_int_param : Error<
"expected a reference to an integer-typed parameter">; "expected a reference to an integer-typed parameter">;
def err_omp_at_least_one_motion_clause_required : Error< def err_omp_at_least_one_motion_clause_required : Error<
"expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'">; "expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'">;
def err_omp_usedeviceptr_not_a_pointer : Error< def err_omp_usedeviceptr_not_a_pointer : Error<
"expected pointer or reference to pointer in 'use_device_ptr' clause">; "expected pointer or reference to pointer in 'use_device_ptr' clause">;
def err_omp_argument_type_isdeviceptr : Error < def err_omp_argument_type_isdeviceptr : Error <
"expected pointer, array, reference to pointer, or reference to array in 'is_device_ptr clause'">; "expected pointer, array, reference to pointer, or reference to array in 'is_device_ptr clause'">;
def warn_omp_nesting_simd : Warning< def warn_omp_nesting_simd : Warning<
"OpenMP only allows an ordered construct with the simd clause nested in a simd construct">, "OpenMP only allows an ordered construct with the simd clause nested in a simd construct">,
InGroup<SourceUsesOpenMP>; InGroup<SourceUsesOpenMP>;
def err_omp_orphaned_device_directive : Error< def err_omp_orphaned_device_directive : Error<
"orphaned 'omp %0' directives are prohibited" "orphaned 'omp %0' directives are prohibited"
▲ Show 20 Lines • Show All 288 Lines • Show Last 20 Lines

include/clang/CodeGen/SwiftCallingConv.h

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Lines
/// Classify the rules for how to pass a particular type. /// Classify the rules for how to pass a particular type.
ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type); ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type);
/// Compute the ABI information of a swiftcall function. This is a /// Compute the ABI information of a swiftcall function. This is a
/// private interface for Clang. /// private interface for Clang.
void computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI); void computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);
/// Is swifterror lowered to a register by the target ABI.
bool isSwiftErrorLoweredInRegister(CodeGenModule &CGM);
} // end namespace swiftcall } // end namespace swiftcall
} // end namespace CodeGen } // end namespace CodeGen
} // end namespace clang } // end namespace clang
#endif #endif

include/clang/Driver/CC1Options.td

Show First 20 Lines • Show All 737 Lines • ▼ Show 20 Linesdef show_encoding : Flag<["-"], "show-encoding">,
HelpText<"Show instruction encoding information in transliterate mode">; HelpText<"Show instruction encoding information in transliterate mode">;
def show_inst : Flag<["-"], "show-inst">, def show_inst : Flag<["-"], "show-inst">,
HelpText<"Show internal instruction representation in transliterate mode">; HelpText<"Show internal instruction representation in transliterate mode">;
// Assemble Options // Assemble Options
def dwarf_debug_producer : Separate<["-"], "dwarf-debug-producer">, def dwarf_debug_producer : Separate<["-"], "dwarf-debug-producer">,
HelpText<"The string to embed in the Dwarf debug AT_producer record.">; HelpText<"The string to embed in the Dwarf debug AT_producer record.">;
def defsym : Separate<["-"], "defsym">,
HelpText<"Define a value for a symbol">;
} // let Flags = [CC1AsOption] } // let Flags = [CC1AsOption]

include/clang/Format/Format.h

Show First 20 Lines • Show All 780 Lines • ▼ Show 20 LinesformatReplacements(StringRef Code, const tooling::Replacements &Replaces,
const FormatStyle &Style); const FormatStyle &Style);
/// \brief Returns the replacements corresponding to applying \p Replaces and /// \brief Returns the replacements corresponding to applying \p Replaces and
/// cleaning up the code after that on success; otherwise, return an llvm::Error /// cleaning up the code after that on success; otherwise, return an llvm::Error
/// carrying llvm::StringError. /// carrying llvm::StringError.
/// This also supports inserting/deleting C++ #include directives: /// This also supports inserting/deleting C++ #include directives:
/// - If a replacement has offset UINT_MAX, length 0, and a replacement text /// - If a replacement has offset UINT_MAX, length 0, and a replacement text
/// that is an #include directive, this will insert the #include into the /// that is an #include directive, this will insert the #include into the
/// correct block in the \p Code. /// correct block in the \p Code. When searching for points to insert new
/// header, this ignores #include's after the #include block(s) in the
/// beginning of a file to avoid inserting headers into code sections where
/// new #include's should not be added by default. These code sections
/// include:
/// - raw string literals (containing #include).
/// - #if blocks.
/// - Special #include's among declarations (e.g. functions).
/// - If a replacement has offset UINT_MAX, length 1, and a replacement text /// - If a replacement has offset UINT_MAX, length 1, and a replacement text
/// that is the name of the header to be removed, the header will be removed /// that is the name of the header to be removed, the header will be removed
/// from \p Code if it exists. /// from \p Code if it exists.
llvm::Expected<tooling::Replacements> llvm::Expected<tooling::Replacements>
cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces, cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
const FormatStyle &Style); const FormatStyle &Style);
/// \brief Reformats the given \p Ranges in \p Code. /// \brief Reformats the given \p Ranges in \p Code.
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

include/clang/Sema/Sema.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 8,709 Lines • ▼ Show 20 Linespublic:
// type. // type.
ExprResult DefaultLvalueConversion(Expr *E); ExprResult DefaultLvalueConversion(Expr *E);
// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
// do not have a prototype. Integer promotions are performed on each // do not have a prototype. Integer promotions are performed on each
// argument, and arguments that have type float are promoted to double. // argument, and arguments that have type float are promoted to double.
ExprResult DefaultArgumentPromotion(Expr *E); ExprResult DefaultArgumentPromotion(Expr *E);
/// If \p E is a prvalue denoting an unmaterialized temporary, materialize
/// it as an xvalue. In C++98, the result will still be a prvalue, because
/// we don't have xvalues there.
ExprResult TemporaryMaterializationConversion(Expr *E);
// Used for emitting the right warning by DefaultVariadicArgumentPromotion // Used for emitting the right warning by DefaultVariadicArgumentPromotion
enum VariadicCallType { enum VariadicCallType {
VariadicFunction, VariadicFunction,
VariadicBlock, VariadicBlock,
VariadicMethod, VariadicMethod,
VariadicConstructor, VariadicConstructor,
VariadicDoesNotApply VariadicDoesNotApply
}; };
▲ Show 20 Lines • Show All 1,364 Lines • Show Last 20 Lines

include/clang/Tooling/CompilationDatabase.h

Show All 37 Lines
namespace clang { namespace clang {
namespace tooling { namespace tooling {
/// \brief Specifies the working directory and command of a compilation. /// \brief Specifies the working directory and command of a compilation.
struct CompileCommand { struct CompileCommand {
CompileCommand() {} CompileCommand() {}
CompileCommand(Twine Directory, Twine Filename, CompileCommand(Twine Directory, Twine Filename,
std::vector<std::string> CommandLine) std::vector<std::string> CommandLine, Twine Output)
: Directory(Directory.str()), : Directory(Directory.str()),
Filename(Filename.str()), Filename(Filename.str()),
CommandLine(std::move(CommandLine)) {} CommandLine(std::move(CommandLine)),
Output(Output.str()){}
/// \brief The working directory the command was executed from. /// \brief The working directory the command was executed from.
std::string Directory; std::string Directory;
/// The source file associated with the command. /// The source file associated with the command.
std::string Filename; std::string Filename;
/// \brief The command line that was executed. /// \brief The command line that was executed.
std::vector<std::string> CommandLine; std::vector<std::string> CommandLine;
/// The output file associated with the command.
std::string Output;
/// \brief An optional mapping from each file's path to its content for all /// \brief An optional mapping from each file's path to its content for all
/// files needed for the compilation that are not available via the file /// files needed for the compilation that are not available via the file
/// system. /// system.
/// ///
/// Note that a tool implementation is required to fall back to the file /// Note that a tool implementation is required to fall back to the file
/// system if a source file is not provided in the mapped sources, as /// system if a source file is not provided in the mapped sources, as
/// compilation databases will usually not provide all files in mapped sources /// compilation databases will usually not provide all files in mapped sources
/// for performance reasons. /// for performance reasons.
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

include/clang/Tooling/JSONCompilationDatabase.h

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines JSONCompilationDatabase(std::unique_ptr<llvm::MemoryBuffer> Database,
YAMLStream(this->Database->getBuffer(), SM) {} YAMLStream(this->Database->getBuffer(), SM) {}
/// \brief Parses the database file and creates the index. /// \brief Parses the database file and creates the index.
/// ///
/// Returns whether parsing succeeded. Sets ErrorMessage if parsing /// Returns whether parsing succeeded. Sets ErrorMessage if parsing
/// failed. /// failed.
bool parse(std::string &ErrorMessage); bool parse(std::string &ErrorMessage);
// Tuple (directory, filename, commandline) where 'commandline' points to the // Tuple (directory, filename, commandline, output) where 'commandline'
// corresponding scalar nodes in the YAML stream. // points to the corresponding scalar nodes in the YAML stream.
// If the command line contains a single argument, it is a shell-escaped // If the command line contains a single argument, it is a shell-escaped
// command line. // command line.
// Otherwise, each entry in the command line vector is a literal // Otherwise, each entry in the command line vector is a literal
// argument to the compiler. // argument to the compiler.
// The output field may be a nullptr.
typedef std::tuple<llvm::yaml::ScalarNode *, typedef std::tuple<llvm::yaml::ScalarNode *,
llvm::yaml::ScalarNode *, llvm::yaml::ScalarNode *,
std::vector<llvm::yaml::ScalarNode *>> CompileCommandRef; std::vector<llvm::yaml::ScalarNode *>,
llvm::yaml::ScalarNode *> CompileCommandRef;
/// \brief Converts the given array of CompileCommandRefs to CompileCommands. /// \brief Converts the given array of CompileCommandRefs to CompileCommands.
void getCommands(ArrayRef<CompileCommandRef> CommandsRef, void getCommands(ArrayRef<CompileCommandRef> CommandsRef,
std::vector<CompileCommand> &Commands) const; std::vector<CompileCommand> &Commands) const;
// Maps file paths to the compile command lines for that file. // Maps file paths to the compile command lines for that file.
llvm::StringMap<std::vector<CompileCommandRef>> IndexByFile; llvm::StringMap<std::vector<CompileCommandRef>> IndexByFile;
Show All 16 Lines

lib/AST/DeclCXX.cpp

Show First 20 Lines • Show All 527 Lines • ▼ Show 20 Lines if (!FunTmpl) {
if (Constructor->isCopyConstructor(Quals)) { if (Constructor->isCopyConstructor(Quals)) {
SMKind |= SMF_CopyConstructor; SMKind |= SMF_CopyConstructor;
if (Quals & Qualifiers::Const) if (Quals & Qualifiers::Const)
data().HasDeclaredCopyConstructorWithConstParam = true; data().HasDeclaredCopyConstructorWithConstParam = true;
} else if (Constructor->isMoveConstructor()) } else if (Constructor->isMoveConstructor())
SMKind |= SMF_MoveConstructor; SMKind |= SMF_MoveConstructor;
} }
// C++ [dcl.init.aggr]p1:
// An aggregate is an array or a class with no user-declared
// constructors [...].
// C++11 [dcl.init.aggr]p1: DR1518
// An aggregate is an array or a class with no user-provided, explicit, or
// inherited constructors
if (getASTContext().getLangOpts().CPlusPlus11
? (Constructor->isUserProvided() || Constructor->isExplicit())
: !Constructor->isImplicit())
data().Aggregate = false;
} }
// Handle constructors, including those inherited from base classes. // Handle constructors, including those inherited from base classes.
if (CXXConstructorDecl *Constructor = if (CXXConstructorDecl *Constructor =
dyn_cast<CXXConstructorDecl>(DUnderlying)) { dyn_cast<CXXConstructorDecl>(DUnderlying)) {
// Record if we see any constexpr constructors which are neither copy // Record if we see any constexpr constructors which are neither copy
// nor move constructors. // nor move constructors.
// C++1z [basic.types]p10: // C++1z [basic.types]p10:
// [...] has at least one constexpr constructor or constructor template // [...] has at least one constexpr constructor or constructor template
// (possibly inherited from a base class) that is not a copy or move // (possibly inherited from a base class) that is not a copy or move
// constructor [...] // constructor [...]
if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor()) if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor())
data().HasConstexprNonCopyMoveConstructor = true; data().HasConstexprNonCopyMoveConstructor = true;
// C++ [dcl.init.aggr]p1:
// An aggregate is an array or a class with no user-declared
// constructors [...].
// C++11 [dcl.init.aggr]p1:
// An aggregate is an array or a class with no user-provided
// constructors [...].
// C++11 [dcl.init.aggr]p1:
// An aggregate is an array or a class with no user-provided
// constructors (including those inherited from a base class) [...].
if (getASTContext().getLangOpts().CPlusPlus11
? Constructor->isUserProvided()
: !Constructor->isImplicit())
data().Aggregate = false;
} }
// Handle destructors. // Handle destructors.
if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) { if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) {
SMKind |= SMF_Destructor; SMKind |= SMF_Destructor;
if (DD->isUserProvided()) if (DD->isUserProvided())
data().HasIrrelevantDestructor = false; data().HasIrrelevantDestructor = false;
▲ Show 20 Lines • Show All 413 Lines • ▼ Show 20 Lines if (Shadow->getDeclName().getNameKind()
== DeclarationName::CXXConversionFunctionName) { == DeclarationName::CXXConversionFunctionName) {
ASTContext &Ctx = getASTContext(); ASTContext &Ctx = getASTContext();
data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess()); data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess());
} }
} }
if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) { if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) {
if (Using->getDeclName().getNameKind() == if (Using->getDeclName().getNameKind() ==
DeclarationName::CXXConstructorName) DeclarationName::CXXConstructorName) {
data().HasInheritedConstructor = true; data().HasInheritedConstructor = true;
// C++1z [dcl.init.aggr]p1:
// An aggregate is [...] a class [...] with no inherited constructors
data().Aggregate = false;
}
if (Using->getDeclName().getCXXOverloadedOperator() == OO_Equal) if (Using->getDeclName().getCXXOverloadedOperator() == OO_Equal)
data().HasInheritedAssignment = true; data().HasInheritedAssignment = true;
} }
} }
void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) { void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) {
assert(!D->isImplicit() && !D->isUserProvided()); assert(!D->isImplicit() && !D->isUserProvided());
▲ Show 20 Lines • Show All 1,445 Lines • Show Last 20 Lines

lib/AST/DeclTemplate.cpp

Show All 30 Lines
TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc, TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
SourceLocation LAngleLoc, SourceLocation LAngleLoc,
ArrayRef<NamedDecl *> Params, ArrayRef<NamedDecl *> Params,
SourceLocation RAngleLoc, SourceLocation RAngleLoc,
Expr *RequiresClause) Expr *RequiresClause)
: TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc), : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
NumParams(Params.size()), ContainsUnexpandedParameterPack(false), NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
HasRequiresClause(static_cast<bool>(RequiresClause)) { HasRequiresClause(static_cast<bool>(RequiresClause)) {
assert(this->NumParams == NumParams && "Too many template parameters");
for (unsigned Idx = 0; Idx < NumParams; ++Idx) { for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
NamedDecl *P = Params[Idx]; NamedDecl *P = Params[Idx];
begin()[Idx] = P; begin()[Idx] = P;
if (!P->isTemplateParameterPack()) { if (!P->isTemplateParameterPack()) {
if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
if (NTTP->getType()->containsUnexpandedParameterPack()) if (NTTP->getType()->containsUnexpandedParameterPack())
ContainsUnexpandedParameterPack = true; ContainsUnexpandedParameterPack = true;
▲ Show 20 Lines • Show All 1,201 Lines • Show Last 20 Lines

lib/AST/ExprClassification.cpp

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Lines#include "clang/AST/StmtNodes.inc"
case Expr::ObjCIvarRefExprClass: case Expr::ObjCIvarRefExprClass:
case Expr::FunctionParmPackExprClass: case Expr::FunctionParmPackExprClass:
case Expr::MSPropertyRefExprClass: case Expr::MSPropertyRefExprClass:
case Expr::MSPropertySubscriptExprClass: case Expr::MSPropertySubscriptExprClass:
case Expr::OMPArraySectionExprClass: case Expr::OMPArraySectionExprClass:
return Cl::CL_LValue; return Cl::CL_LValue;
// C99 6.5.2.5p5 says that compound literals are lvalues. // C99 6.5.2.5p5 says that compound literals are lvalues.
// In C++, they're prvalue temporaries. // In C++, they're prvalue temporaries, except for file-scope arrays.
case Expr::CompoundLiteralExprClass: case Expr::CompoundLiteralExprClass:
return Ctx.getLangOpts().CPlusPlus ? ClassifyTemporary(E->getType()) return !E->isLValue() ? ClassifyTemporary(E->getType()) : Cl::CL_LValue;
: Cl::CL_LValue;
// Expressions that are prvalues. // Expressions that are prvalues.
case Expr::CXXBoolLiteralExprClass: case Expr::CXXBoolLiteralExprClass:
case Expr::CXXPseudoDestructorExprClass: case Expr::CXXPseudoDestructorExprClass:
case Expr::UnaryExprOrTypeTraitExprClass: case Expr::UnaryExprOrTypeTraitExprClass:
case Expr::CXXNewExprClass: case Expr::CXXNewExprClass:
case Expr::CXXThisExprClass: case Expr::CXXThisExprClass:
case Expr::CXXNullPtrLiteralExprClass: case Expr::CXXNullPtrLiteralExprClass:
Show All 35 Lines#include "clang/AST/StmtNodes.inc"
case Expr::CoyieldExprClass: case Expr::CoyieldExprClass:
return Cl::CL_PRValue; return Cl::CL_PRValue;
// Next come the complicated cases. // Next come the complicated cases.
case Expr::SubstNonTypeTemplateParmExprClass: case Expr::SubstNonTypeTemplateParmExprClass:
return ClassifyInternal(Ctx, return ClassifyInternal(Ctx,
cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement()); cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
// C++ [expr.sub]p1: The result is an lvalue of type "T". // C, C++98 [expr.sub]p1: The result is an lvalue of type "T".
// However, subscripting vector types is more like member access. // C++11 (DR1213): in the case of an array operand, the result is an lvalue
// if that operand is an lvalue and an xvalue otherwise.
// Subscripting vector types is more like member access.
case Expr::ArraySubscriptExprClass: case Expr::ArraySubscriptExprClass:
if (cast<ArraySubscriptExpr>(E)->getBase()->getType()->isVectorType()) if (cast<ArraySubscriptExpr>(E)->getBase()->getType()->isVectorType())
return ClassifyInternal(Ctx, cast<ArraySubscriptExpr>(E)->getBase()); return ClassifyInternal(Ctx, cast<ArraySubscriptExpr>(E)->getBase());
if (Lang.CPlusPlus11) {
// Step over the array-to-pointer decay if present, but not over the
// temporary materialization.
auto *Base = cast<ArraySubscriptExpr>(E)->getBase()->IgnoreImpCasts();
if (Base->getType()->isArrayType())
return ClassifyInternal(Ctx, Base);
}
return Cl::CL_LValue; return Cl::CL_LValue;
// C++ [expr.prim.general]p3: The result is an lvalue if the entity is a // C++ [expr.prim.general]p3: The result is an lvalue if the entity is a
// function or variable and a prvalue otherwise. // function or variable and a prvalue otherwise.
case Expr::DeclRefExprClass: case Expr::DeclRefExprClass:
if (E->getType() == Ctx.UnknownAnyTy) if (E->getType() == Ctx.UnknownAnyTy)
return isa<FunctionDecl>(cast<DeclRefExpr>(E)->getDecl()) return isa<FunctionDecl>(cast<DeclRefExpr>(E)->getDecl())
? Cl::CL_PRValue : Cl::CL_LValue; ? Cl::CL_PRValue : Cl::CL_LValue;
▲ Show 20 Lines • Show All 480 Lines • Show Last 20 Lines

lib/AST/ExprConstant.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,901 Lines • ▼ Show 20 Linesstatic bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
// Check for special cases where there is no existing APValue to look at. // Check for special cases where there is no existing APValue to look at.
const Expr *Base = LVal.Base.dyn_cast<const Expr*>(); const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
if (Base && !LVal.CallIndex && !Type.isVolatileQualified()) { if (Base && !LVal.CallIndex && !Type.isVolatileQualified()) {
if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) { if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
// In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the
// initializer until now for such expressions. Such an expression can't be // initializer until now for such expressions. Such an expression can't be
// an ICE in C, so this only matters for fold. // an ICE in C, so this only matters for fold.
assert(!Info.getLangOpts().CPlusPlus && "lvalue compound literal in c++?");
if (Type.isVolatileQualified()) { if (Type.isVolatileQualified()) {
Info.FFDiag(Conv); Info.FFDiag(Conv);
return false; return false;
} }
APValue Lit; APValue Lit;
if (!Evaluate(Lit, Info, CLE->getInitializer())) if (!Evaluate(Lit, Info, CLE->getInitializer()))
return false; return false;
CompleteObject LitObj(&Lit, Base->getType()); CompleteObject LitObj(&Lit, Base->getType());
▲ Show 20 Lines • Show All 1,787 Lines • ▼ Show 20 Lines
// temporaries (if building with -Wno-address-of-temporary). // temporaries (if building with -Wno-address-of-temporary).
// //
// LValue evaluation produces values comprising a base expression of one of the // LValue evaluation produces values comprising a base expression of one of the
// following types: // following types:
// - Declarations // - Declarations
// * VarDecl // * VarDecl
// * FunctionDecl // * FunctionDecl
// - Literals // - Literals
// * CompoundLiteralExpr in C // * CompoundLiteralExpr in C (and in global scope in C++)
// * StringLiteral // * StringLiteral
// * CXXTypeidExpr // * CXXTypeidExpr
// * PredefinedExpr // * PredefinedExpr
// * ObjCStringLiteralExpr // * ObjCStringLiteralExpr
// * ObjCEncodeExpr // * ObjCEncodeExpr
// * AddrLabelExpr // * AddrLabelExpr
// * BlockExpr // * BlockExpr
// * CallExpr for a MakeStringConstant builtin // * CallExpr for a MakeStringConstant builtin
▲ Show 20 Lines • Show All 178 Lines • ▼ Show 20 Lines for (unsigned I = Adjustments.size(); I != 0; /**/) {
} }
} }
return true; return true;
} }
bool bool
LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
assert(!Info.getLangOpts().CPlusPlus && "lvalue compound literal in c++?"); assert((!Info.getLangOpts().CPlusPlus || E->isFileScope()) &&
"lvalue compound literal in c++?");
// Defer visiting the literal until the lvalue-to-rvalue conversion. We can // Defer visiting the literal until the lvalue-to-rvalue conversion. We can
// only see this when folding in C, so there's no standard to follow here. // only see this when folding in C, so there's no standard to follow here.
return Success(E); return Success(E);
} }
bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) { bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
if (!E->isPotentiallyEvaluated()) if (!E->isPotentiallyEvaluated())
return Success(E); return Success(E);
▲ Show 20 Lines • Show All 5,183 Lines • Show Last 20 Lines

lib/Analysis/CFG.cpp

Show First 20 Lines • Show All 3,575 Lines • ▼ Show 20 LinesCFGBlock *CFGBuilder::VisitCXXNewExpr(CXXNewExpr *NE,
return Block; return Block;
} }
CFGBlock *CFGBuilder::VisitCXXDeleteExpr(CXXDeleteExpr *DE, CFGBlock *CFGBuilder::VisitCXXDeleteExpr(CXXDeleteExpr *DE,
AddStmtChoice asc) { AddStmtChoice asc) {
autoCreateBlock(); autoCreateBlock();
appendStmt(Block, DE); appendStmt(Block, DE);
QualType DTy = DE->getDestroyedType(); QualType DTy = DE->getDestroyedType();
if (!DTy.isNull()) {
DTy = DTy.getNonReferenceType(); DTy = DTy.getNonReferenceType();
CXXRecordDecl *RD = Context->getBaseElementType(DTy)->getAsCXXRecordDecl(); CXXRecordDecl *RD = Context->getBaseElementType(DTy)->getAsCXXRecordDecl();
if (RD) { if (RD) {
if (RD->isCompleteDefinition() && !RD->hasTrivialDestructor()) if (RD->isCompleteDefinition() && !RD->hasTrivialDestructor())
appendDeleteDtor(Block, RD, DE); appendDeleteDtor(Block, RD, DE);
} }
}
return VisitChildren(DE); return VisitChildren(DE);
} }
CFGBlock *CFGBuilder::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E, CFGBlock *CFGBuilder::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E,
AddStmtChoice asc) { AddStmtChoice asc) {
if (asc.alwaysAdd(*this, E)) { if (asc.alwaysAdd(*this, E)) {
autoCreateBlock(); autoCreateBlock();
▲ Show 20 Lines • Show All 1,092 Lines • Show Last 20 Lines

lib/Analysis/ThreadSafety.cpp

Show First 20 Lines • Show All 1,577 Lines • ▼ Show 20 Lines
/// \brief Checks guarded_by and pt_guarded_by attributes. /// \brief Checks guarded_by and pt_guarded_by attributes.
/// Whenever we identify an access (read or write) to a DeclRefExpr that is /// Whenever we identify an access (read or write) to a DeclRefExpr that is
/// marked with guarded_by, we must ensure the appropriate mutexes are held. /// marked with guarded_by, we must ensure the appropriate mutexes are held.
/// Similarly, we check if the access is to an expression that dereferences /// Similarly, we check if the access is to an expression that dereferences
/// a pointer marked with pt_guarded_by. /// a pointer marked with pt_guarded_by.
void BuildLockset::checkAccess(const Expr *Exp, AccessKind AK, void BuildLockset::checkAccess(const Expr *Exp, AccessKind AK,
ProtectedOperationKind POK) { ProtectedOperationKind POK) {
Exp = Exp->IgnoreParenCasts(); Exp = Exp->IgnoreImplicit()->IgnoreParenCasts();
SourceLocation Loc = Exp->getExprLoc(); SourceLocation Loc = Exp->getExprLoc();
// Local variables of reference type cannot be re-assigned; // Local variables of reference type cannot be re-assigned;
// map them to their initializer. // map them to their initializer.
while (const auto *DRE = dyn_cast<DeclRefExpr>(Exp)) { while (const auto *DRE = dyn_cast<DeclRefExpr>(Exp)) {
const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()->getCanonicalDecl()); const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()->getCanonicalDecl());
if (VD && VD->isLocalVarDecl() && VD->getType()->isReferenceType()) { if (VD && VD->isLocalVarDecl() && VD->getType()->isReferenceType()) {
▲ Show 20 Lines • Show All 810 Lines • Show Last 20 Lines

lib/Analysis/ThreadSafetyCommon.cpp

Show First 20 Lines • Show All 227 Lines • ▼ Show 20 Linestil::SExpr *SExprBuilder::translate(const Stmt *S, CallingContext *Ctx) {
// We treat these as no-ops // We treat these as no-ops
case Stmt::ParenExprClass: case Stmt::ParenExprClass:
return translate(cast<ParenExpr>(S)->getSubExpr(), Ctx); return translate(cast<ParenExpr>(S)->getSubExpr(), Ctx);
case Stmt::ExprWithCleanupsClass: case Stmt::ExprWithCleanupsClass:
return translate(cast<ExprWithCleanups>(S)->getSubExpr(), Ctx); return translate(cast<ExprWithCleanups>(S)->getSubExpr(), Ctx);
case Stmt::CXXBindTemporaryExprClass: case Stmt::CXXBindTemporaryExprClass:
return translate(cast<CXXBindTemporaryExpr>(S)->getSubExpr(), Ctx); return translate(cast<CXXBindTemporaryExpr>(S)->getSubExpr(), Ctx);
case Stmt::MaterializeTemporaryExprClass:
return translate(cast<MaterializeTemporaryExpr>(S)->GetTemporaryExpr(),
Ctx);
// Collect all literals // Collect all literals
case Stmt::CharacterLiteralClass: case Stmt::CharacterLiteralClass:
case Stmt::CXXNullPtrLiteralExprClass: case Stmt::CXXNullPtrLiteralExprClass:
case Stmt::GNUNullExprClass: case Stmt::GNUNullExprClass:
case Stmt::CXXBoolLiteralExprClass: case Stmt::CXXBoolLiteralExprClass:
case Stmt::FloatingLiteralClass: case Stmt::FloatingLiteralClass:
case Stmt::ImaginaryLiteralClass: case Stmt::ImaginaryLiteralClass:
▲ Show 20 Lines • Show All 689 Lines • Show Last 20 Lines

lib/CodeGen/ABIInfo.h

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines public:
virtual bool shouldPassIndirectlyForSwift(CharUnits totalSize, virtual bool shouldPassIndirectlyForSwift(CharUnits totalSize,
ArrayRef<llvm::Type*> types, ArrayRef<llvm::Type*> types,
bool asReturnValue) const = 0; bool asReturnValue) const = 0;
virtual bool isLegalVectorTypeForSwift(CharUnits totalSize, virtual bool isLegalVectorTypeForSwift(CharUnits totalSize,
llvm::Type *eltTy, llvm::Type *eltTy,
unsigned elts) const; unsigned elts) const;
virtual bool isSwiftErrorInRegister() const = 0;
static bool classof(const ABIInfo *info) { static bool classof(const ABIInfo *info) {
return info->supportsSwift(); return info->supportsSwift();
} }
}; };
} // end namespace CodeGen } // end namespace CodeGen
} // end namespace clang } // end namespace clang
#endif #endif

lib/CodeGen/CGBuilder.h

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align,
return CreateAlignedLoad(Addr, Align.getQuantity(), Name); return CreateAlignedLoad(Addr, Align.getQuantity(), Name);
} }
llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr,
CharUnits Align, CharUnits Align,
const llvm::Twine &Name = "") { const llvm::Twine &Name = "") {
assert(Addr->getType()->getPointerElementType() == Ty); assert(Addr->getType()->getPointerElementType() == Ty);
return CreateAlignedLoad(Addr, Align.getQuantity(), Name); return CreateAlignedLoad(Addr, Align.getQuantity(), Name);
} }
llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align,
bool IsVolatile,
const llvm::Twine &Name = "") {
return CreateAlignedLoad(Addr, Align.getQuantity(), IsVolatile, Name);
}
// Note that we intentionally hide the CreateStore APIs that don't // Note that we intentionally hide the CreateStore APIs that don't
// take an alignment. // take an alignment.
llvm::StoreInst *CreateStore(llvm::Value *Val, Address Addr, llvm::StoreInst *CreateStore(llvm::Value *Val, Address Addr,
bool IsVolatile = false) { bool IsVolatile = false) {
return CreateAlignedStore(Val, Addr.getPointer(), return CreateAlignedStore(Val, Addr.getPointer(),
Addr.getAlignment().getQuantity(), IsVolatile); Addr.getAlignment().getQuantity(), IsVolatile);
} }
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

lib/CodeGen/CGBuiltin.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,432 Lines • ▼ Show 20 LinesValue *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID,
} }
if (BuiltinID == ARM::BI__builtin_arm_ldrex || if (BuiltinID == ARM::BI__builtin_arm_ldrex ||
BuiltinID == ARM::BI__builtin_arm_ldaex) { BuiltinID == ARM::BI__builtin_arm_ldaex) {
Value *LoadAddr = EmitScalarExpr(E->getArg(0)); Value *LoadAddr = EmitScalarExpr(E->getArg(0));
QualType Ty = E->getType(); QualType Ty = E->getType();
llvm::Type *RealResTy = ConvertType(Ty); llvm::Type *RealResTy = ConvertType(Ty);
llvm::Type *IntResTy = llvm::IntegerType::get(getLLVMContext(), llvm::Type *PtrTy = llvm::IntegerType::get(
getContext().getTypeSize(Ty)); getLLVMContext(), getContext().getTypeSize(Ty))->getPointerTo();
LoadAddr = Builder.CreateBitCast(LoadAddr, IntResTy->getPointerTo()); LoadAddr = Builder.CreateBitCast(LoadAddr, PtrTy);
Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_ldaex Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_ldaex
? Intrinsic::arm_ldaex ? Intrinsic::arm_ldaex
: Intrinsic::arm_ldrex, : Intrinsic::arm_ldrex,
LoadAddr->getType()); PtrTy);
Value *Val = Builder.CreateCall(F, LoadAddr, "ldrex"); Value *Val = Builder.CreateCall(F, LoadAddr, "ldrex");
if (RealResTy->isPointerTy()) if (RealResTy->isPointerTy())
return Builder.CreateIntToPtr(Val, RealResTy); return Builder.CreateIntToPtr(Val, RealResTy);
else { else {
llvm::Type *IntResTy = llvm::IntegerType::get(
getLLVMContext(), CGM.getDataLayout().getTypeSizeInBits(RealResTy));
Val = Builder.CreateTruncOrBitCast(Val, IntResTy); Val = Builder.CreateTruncOrBitCast(Val, IntResTy);
return Builder.CreateBitCast(Val, RealResTy); return Builder.CreateBitCast(Val, RealResTy);
} }
} }
if (BuiltinID == ARM::BI__builtin_arm_strexd || if (BuiltinID == ARM::BI__builtin_arm_strexd ||
((BuiltinID == ARM::BI__builtin_arm_stlex || ((BuiltinID == ARM::BI__builtin_arm_stlex ||
BuiltinID == ARM::BI__builtin_arm_strex) && BuiltinID == ARM::BI__builtin_arm_strex) &&
Show All 24 Lines if (BuiltinID == ARM::BI__builtin_arm_strex ||
QualType Ty = E->getArg(0)->getType(); QualType Ty = E->getArg(0)->getType();
llvm::Type *StoreTy = llvm::IntegerType::get(getLLVMContext(), llvm::Type *StoreTy = llvm::IntegerType::get(getLLVMContext(),
getContext().getTypeSize(Ty)); getContext().getTypeSize(Ty));
StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo()); StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
if (StoreVal->getType()->isPointerTy()) if (StoreVal->getType()->isPointerTy())
StoreVal = Builder.CreatePtrToInt(StoreVal, Int32Ty); StoreVal = Builder.CreatePtrToInt(StoreVal, Int32Ty);
else { else {
StoreVal = Builder.CreateBitCast(StoreVal, StoreTy); llvm::Type *IntTy = llvm::IntegerType::get(
getLLVMContext(),
CGM.getDataLayout().getTypeSizeInBits(StoreVal->getType()));
StoreVal = Builder.CreateBitCast(StoreVal, IntTy);
StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int32Ty); StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int32Ty);
} }
Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_stlex Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_stlex
? Intrinsic::arm_stlex ? Intrinsic::arm_stlex
: Intrinsic::arm_strex, : Intrinsic::arm_strex,
StoreAddr->getType()); StoreAddr->getType());
return Builder.CreateCall(F, {StoreVal, StoreAddr}, "strex"); return Builder.CreateCall(F, {StoreVal, StoreAddr}, "strex");
▲ Show 20 Lines • Show All 757 Lines • ▼ Show 20 Lines if ((BuiltinID == AArch64::BI__builtin_arm_ldrex ||
Val = Builder.CreateOr(Val, Val1); Val = Builder.CreateOr(Val, Val1);
return Builder.CreateBitCast(Val, ConvertType(E->getType())); return Builder.CreateBitCast(Val, ConvertType(E->getType()));
} else if (BuiltinID == AArch64::BI__builtin_arm_ldrex || } else if (BuiltinID == AArch64::BI__builtin_arm_ldrex ||
BuiltinID == AArch64::BI__builtin_arm_ldaex) { BuiltinID == AArch64::BI__builtin_arm_ldaex) {
Value *LoadAddr = EmitScalarExpr(E->getArg(0)); Value *LoadAddr = EmitScalarExpr(E->getArg(0));
QualType Ty = E->getType(); QualType Ty = E->getType();
llvm::Type *RealResTy = ConvertType(Ty); llvm::Type *RealResTy = ConvertType(Ty);
llvm::Type *IntResTy = llvm::IntegerType::get(getLLVMContext(), llvm::Type *PtrTy = llvm::IntegerType::get(
getContext().getTypeSize(Ty)); getLLVMContext(), getContext().getTypeSize(Ty))->getPointerTo();
LoadAddr = Builder.CreateBitCast(LoadAddr, IntResTy->getPointerTo()); LoadAddr = Builder.CreateBitCast(LoadAddr, PtrTy);
Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_ldaex Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_ldaex
? Intrinsic::aarch64_ldaxr ? Intrinsic::aarch64_ldaxr
: Intrinsic::aarch64_ldxr, : Intrinsic::aarch64_ldxr,
LoadAddr->getType()); PtrTy);
Value *Val = Builder.CreateCall(F, LoadAddr, "ldxr"); Value *Val = Builder.CreateCall(F, LoadAddr, "ldxr");
if (RealResTy->isPointerTy()) if (RealResTy->isPointerTy())
return Builder.CreateIntToPtr(Val, RealResTy); return Builder.CreateIntToPtr(Val, RealResTy);
llvm::Type *IntResTy = llvm::IntegerType::get(
getLLVMContext(), CGM.getDataLayout().getTypeSizeInBits(RealResTy));
Val = Builder.CreateTruncOrBitCast(Val, IntResTy); Val = Builder.CreateTruncOrBitCast(Val, IntResTy);
return Builder.CreateBitCast(Val, RealResTy); return Builder.CreateBitCast(Val, RealResTy);
} }
if ((BuiltinID == AArch64::BI__builtin_arm_strex || if ((BuiltinID == AArch64::BI__builtin_arm_strex ||
BuiltinID == AArch64::BI__builtin_arm_stlex) && BuiltinID == AArch64::BI__builtin_arm_stlex) &&
getContext().getTypeSize(E->getArg(0)->getType()) == 128) { getContext().getTypeSize(E->getArg(0)->getType()) == 128) {
Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_stlex Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_stlex
Show All 22 Lines if (BuiltinID == AArch64::BI__builtin_arm_strex ||
QualType Ty = E->getArg(0)->getType(); QualType Ty = E->getArg(0)->getType();
llvm::Type *StoreTy = llvm::IntegerType::get(getLLVMContext(), llvm::Type *StoreTy = llvm::IntegerType::get(getLLVMContext(),
getContext().getTypeSize(Ty)); getContext().getTypeSize(Ty));
StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo()); StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
if (StoreVal->getType()->isPointerTy()) if (StoreVal->getType()->isPointerTy())
StoreVal = Builder.CreatePtrToInt(StoreVal, Int64Ty); StoreVal = Builder.CreatePtrToInt(StoreVal, Int64Ty);
else { else {
StoreVal = Builder.CreateBitCast(StoreVal, StoreTy); llvm::Type *IntTy = llvm::IntegerType::get(
getLLVMContext(),
CGM.getDataLayout().getTypeSizeInBits(StoreVal->getType()));
StoreVal = Builder.CreateBitCast(StoreVal, IntTy);
StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int64Ty); StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int64Ty);
} }
Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_stlex Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_stlex
? Intrinsic::aarch64_stlxr ? Intrinsic::aarch64_stlxr
: Intrinsic::aarch64_stxr, : Intrinsic::aarch64_stxr,
StoreAddr->getType()); StoreAddr->getType());
return Builder.CreateCall(F, {StoreVal, StoreAddr}, "stxr"); return Builder.CreateCall(F, {StoreVal, StoreAddr}, "stxr");
▲ Show 20 Lines • Show All 3,505 Lines • Show Last 20 Lines

lib/CodeGen/ConstantBuilder.h

Show First 20 Lines • Show All 242 Lines • ▼ Show 20 Lines void getGEPIndicesTo(llvm::SmallVectorImpl<llvm::Constant*> &indices,
size_t position) const { size_t position) const {
// Recurse on the parent builder if present. // Recurse on the parent builder if present.
if (Parent) { if (Parent) {
Parent->getGEPIndicesTo(indices, Begin); Parent->getGEPIndicesTo(indices, Begin);
// Otherwise, add an index to drill into the first level of pointer. // Otherwise, add an index to drill into the first level of pointer.
} else { } else {
assert(indices.empty()); assert(indices.empty());
indices.push_back(llvm::ConstantInt::get(Builder.CGM.SizeTy, 0)); indices.push_back(llvm::ConstantInt::get(Builder.CGM.Int32Ty, 0));
} }
assert(position >= Begin); assert(position >= Begin);
indices.push_back(llvm::ConstantInt::get(Builder.CGM.SizeTy, // We have to use i32 here because struct GEPs demand i32 indices.
// It's rather unlikely to matter in practice.
indices.push_back(llvm::ConstantInt::get(Builder.CGM.Int32Ty,
position - Begin)); position - Begin));
} }
}; };
template <class Impl> template <class Impl>
class AggregateBuilder : public AggregateBuilderBase { class AggregateBuilder : public AggregateBuilderBase {
protected: protected:
AggregateBuilder(ConstantInitBuilder &builder, AggregateBuilder(ConstantInitBuilder &builder,
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

lib/CodeGen/ItaniumCXXABI.cpp

Show First 20 Lines • Show All 2,905 Lines • ▼ Show 20 Linesstatic llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
switch (Ty->getLinkage()) { switch (Ty->getLinkage()) {
case NoLinkage: case NoLinkage:
case InternalLinkage: case InternalLinkage:
case UniqueExternalLinkage: case UniqueExternalLinkage:
return llvm::GlobalValue::InternalLinkage; return llvm::GlobalValue::InternalLinkage;
case VisibleNoLinkage: case VisibleNoLinkage:
case ExternalLinkage: case ExternalLinkage:
if (!CGM.getLangOpts().RTTI) {
// RTTI is not enabled, which means that this type info struct is going // RTTI is not enabled, which means that this type info struct is going
// to be used for exception handling. Give it linkonce_odr linkage. // to be used for exception handling. Give it linkonce_odr linkage.
if (!CGM.getLangOpts().RTTI)
return llvm::GlobalValue::LinkOnceODRLinkage; return llvm::GlobalValue::LinkOnceODRLinkage;
}
if (const RecordType *Record = dyn_cast<RecordType>(Ty)) { if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()); const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
if (RD->hasAttr<WeakAttr>()) if (RD->hasAttr<WeakAttr>())
return llvm::GlobalValue::WeakODRLinkage; return llvm::GlobalValue::WeakODRLinkage;
if (CGM.getTriple().isWindowsItaniumEnvironment())
if (RD->hasAttr<DLLImportAttr>())
return llvm::GlobalValue::ExternalLinkage;
if (RD->isDynamicClass()) { if (RD->isDynamicClass()) {
llvm::GlobalValue::LinkageTypes LT = CGM.getVTableLinkage(RD); llvm::GlobalValue::LinkageTypes LT = CGM.getVTableLinkage(RD);
// MinGW won't export the RTTI information when there is a key function. // MinGW won't export the RTTI information when there is a key function.
// Make sure we emit our own copy instead of attempting to dllimport it. // Make sure we emit our own copy instead of attempting to dllimport it.
if (RD->hasAttr<DLLImportAttr>() && if (RD->hasAttr<DLLImportAttr>() &&
llvm::GlobalValue::isAvailableExternallyLinkage(LT)) llvm::GlobalValue::isAvailableExternallyLinkage(LT))
LT = llvm::GlobalValue::LinkOnceODRLinkage; LT = llvm::GlobalValue::LinkOnceODRLinkage;
return LT; return LT;
▲ Show 20 Lines • Show All 185 Lines • ▼ Show 20 Lines#include "clang/AST/TypeNodes.def"
llvm::GlobalValue::VisibilityTypes llvmVisibility; llvm::GlobalValue::VisibilityTypes llvmVisibility;
if (llvm::GlobalValue::isLocalLinkage(Linkage)) if (llvm::GlobalValue::isLocalLinkage(Linkage))
// If the linkage is local, only default visibility makes sense. // If the linkage is local, only default visibility makes sense.
llvmVisibility = llvm::GlobalValue::DefaultVisibility; llvmVisibility = llvm::GlobalValue::DefaultVisibility;
else if (RTTIUniqueness == ItaniumCXXABI::RUK_NonUniqueHidden) else if (RTTIUniqueness == ItaniumCXXABI::RUK_NonUniqueHidden)
llvmVisibility = llvm::GlobalValue::HiddenVisibility; llvmVisibility = llvm::GlobalValue::HiddenVisibility;
else else
llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility()); llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
TypeName->setVisibility(llvmVisibility); TypeName->setVisibility(llvmVisibility);
GV->setVisibility(llvmVisibility); GV->setVisibility(llvmVisibility);
if (DLLExport)
if (CGM.getTriple().isWindowsItaniumEnvironment()) {
auto RD = Ty->getAsCXXRecordDecl();
if (DLLExport || (RD && RD->hasAttr<DLLExportAttr>())) {
TypeName->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
} else if (RD && RD->hasAttr<DLLImportAttr>()) {
TypeName->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
// Because the typename and the typeinfo are DLL import, convert them to
// declarations rather than definitions. The initializers still need to
// be constructed to calculate the type for the declarations.
TypeName->setInitializer(nullptr);
GV->setInitializer(nullptr);
}
}
return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy); return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
} }
/// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info /// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info
/// for the given Objective-C object type. /// for the given Objective-C object type.
void ItaniumRTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) { void ItaniumRTTIBuilder::BuildObjCObjectTypeInfo(const ObjCObjectType *OT) {
// Drop qualifiers. // Drop qualifiers.
▲ Show 20 Lines • Show All 798 Lines • Show Last 20 Lines

lib/CodeGen/SwiftCallingConv.cpp

Show First 20 Lines • Show All 822 Lines • ▼ Show 20 Linesvoid swiftcall::computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI) {
auto &retInfo = FI.getReturnInfo(); auto &retInfo = FI.getReturnInfo();
retInfo = classifyReturnType(CGM, FI.getReturnType()); retInfo = classifyReturnType(CGM, FI.getReturnType());
for (unsigned i = 0, e = FI.arg_size(); i != e; ++i) { for (unsigned i = 0, e = FI.arg_size(); i != e; ++i) {
auto &argInfo = FI.arg_begin()[i]; auto &argInfo = FI.arg_begin()[i];
argInfo.info = classifyArgumentType(CGM, argInfo.type); argInfo.info = classifyArgumentType(CGM, argInfo.type);
} }
} }
// Is swifterror lowered to a register by the target ABI.
bool swiftcall::isSwiftErrorLoweredInRegister(CodeGenModule &CGM) {
return getSwiftABIInfo(CGM).isSwiftErrorInRegister();
}

lib/CodeGen/TargetInfo.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 952 Lines • ▼ Show 20 Lines bool shouldPassIndirectlyForSwift(CharUnits totalSize,
ArrayRef<llvm::Type*> scalars, ArrayRef<llvm::Type*> scalars,
bool asReturnValue) const override { bool asReturnValue) const override {
// LLVM's x86-32 lowering currently only assigns up to three // LLVM's x86-32 lowering currently only assigns up to three
// integer registers and three fp registers. Oddly, it'll use up to // integer registers and three fp registers. Oddly, it'll use up to
// four vector registers for vectors, but those can overlap with the // four vector registers for vectors, but those can overlap with the
// scalar registers. // scalar registers.
return occupiesMoreThan(CGT, scalars, /*total*/ 3); return occupiesMoreThan(CGT, scalars, /*total*/ 3);
} }
bool isSwiftErrorInRegister() const override {
// x86-32 lowering does not support passing swifterror in a register.
return false;
}
}; };
class X86_32TargetCodeGenInfo : public TargetCodeGenInfo { class X86_32TargetCodeGenInfo : public TargetCodeGenInfo {
public: public:
X86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool DarwinVectorABI, X86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool DarwinVectorABI,
bool RetSmallStructInRegABI, bool Win32StructABI, bool RetSmallStructInRegABI, bool Win32StructABI,
unsigned NumRegisterParameters, bool SoftFloatABI) unsigned NumRegisterParameters, bool SoftFloatABI)
: TargetCodeGenInfo(new X86_32ABIInfo( : TargetCodeGenInfo(new X86_32ABIInfo(
▲ Show 20 Lines • Show All 1,038 Lines • ▼ Show 20 Lines bool has64BitPointers() const {
return Has64BitPointers; return Has64BitPointers;
} }
bool shouldPassIndirectlyForSwift(CharUnits totalSize, bool shouldPassIndirectlyForSwift(CharUnits totalSize,
ArrayRef<llvm::Type*> scalars, ArrayRef<llvm::Type*> scalars,
bool asReturnValue) const override { bool asReturnValue) const override {
return occupiesMoreThan(CGT, scalars, /*total*/ 4); return occupiesMoreThan(CGT, scalars, /*total*/ 4);
} }
bool isSwiftErrorInRegister() const override {
return true;
}
}; };
/// WinX86_64ABIInfo - The Windows X86_64 ABI information. /// WinX86_64ABIInfo - The Windows X86_64 ABI information.
class WinX86_64ABIInfo : public SwiftABIInfo { class WinX86_64ABIInfo : public SwiftABIInfo {
public: public:
WinX86_64ABIInfo(CodeGen::CodeGenTypes &CGT) WinX86_64ABIInfo(CodeGen::CodeGenTypes &CGT)
: SwiftABIInfo(CGT), : SwiftABIInfo(CGT),
IsMingw64(getTarget().getTriple().isWindowsGNUEnvironment()) {} IsMingw64(getTarget().getTriple().isWindowsGNUEnvironment()) {}
Show All 15 Linespublic:
} }
bool shouldPassIndirectlyForSwift(CharUnits totalSize, bool shouldPassIndirectlyForSwift(CharUnits totalSize,
ArrayRef<llvm::Type *> scalars, ArrayRef<llvm::Type *> scalars,
bool asReturnValue) const override { bool asReturnValue) const override {
return occupiesMoreThan(CGT, scalars, /*total*/ 4); return occupiesMoreThan(CGT, scalars, /*total*/ 4);
} }
bool isSwiftErrorInRegister() const override {
return true;
}
private: private:
ABIArgInfo classify(QualType Ty, unsigned &FreeSSERegs, ABIArgInfo classify(QualType Ty, unsigned &FreeSSERegs,
bool IsReturnType) const; bool IsReturnType) const;
bool IsMingw64; bool IsMingw64;
}; };
class X86_64TargetCodeGenInfo : public TargetCodeGenInfo { class X86_64TargetCodeGenInfo : public TargetCodeGenInfo {
▲ Show 20 Lines • Show All 2,569 Lines • ▼ Show 20 Lines return isDarwinPCS() ? EmitDarwinVAArg(VAListAddr, Ty, CGF)
: EmitAAPCSVAArg(VAListAddr, Ty, CGF); : EmitAAPCSVAArg(VAListAddr, Ty, CGF);
} }
bool shouldPassIndirectlyForSwift(CharUnits totalSize, bool shouldPassIndirectlyForSwift(CharUnits totalSize,
ArrayRef<llvm::Type*> scalars, ArrayRef<llvm::Type*> scalars,
bool asReturnValue) const override { bool asReturnValue) const override {
return occupiesMoreThan(CGT, scalars, /*total*/ 4); return occupiesMoreThan(CGT, scalars, /*total*/ 4);
} }
bool isSwiftErrorInRegister() const override {
return true;
}
}; };
class AArch64TargetCodeGenInfo : public TargetCodeGenInfo { class AArch64TargetCodeGenInfo : public TargetCodeGenInfo {
public: public:
AArch64TargetCodeGenInfo(CodeGenTypes &CGT, AArch64ABIInfo::ABIKind Kind) AArch64TargetCodeGenInfo(CodeGenTypes &CGT, AArch64ABIInfo::ABIKind Kind)
: TargetCodeGenInfo(new AArch64ABIInfo(CGT, Kind)) {} : TargetCodeGenInfo(new AArch64ABIInfo(CGT, Kind)) {}
StringRef getARCRetainAutoreleasedReturnValueMarker() const override { StringRef getARCRetainAutoreleasedReturnValueMarker() const override {
▲ Show 20 Lines • Show All 537 Lines • ▼ Show 20 Linesprivate:
llvm::CallingConv::ID getABIDefaultCC() const; llvm::CallingConv::ID getABIDefaultCC() const;
void setCCs(); void setCCs();
bool shouldPassIndirectlyForSwift(CharUnits totalSize, bool shouldPassIndirectlyForSwift(CharUnits totalSize,
ArrayRef<llvm::Type*> scalars, ArrayRef<llvm::Type*> scalars,
bool asReturnValue) const override { bool asReturnValue) const override {
return occupiesMoreThan(CGT, scalars, /*total*/ 4); return occupiesMoreThan(CGT, scalars, /*total*/ 4);
} }
bool isSwiftErrorInRegister() const override {
return true;
}
}; };
class ARMTargetCodeGenInfo : public TargetCodeGenInfo { class ARMTargetCodeGenInfo : public TargetCodeGenInfo {
public: public:
ARMTargetCodeGenInfo(CodeGenTypes &CGT, ARMABIInfo::ABIKind K) ARMTargetCodeGenInfo(CodeGenTypes &CGT, ARMABIInfo::ABIKind K)
:TargetCodeGenInfo(new ARMABIInfo(CGT, K)) {} :TargetCodeGenInfo(new ARMABIInfo(CGT, K)) {}
const ARMABIInfo &getABIInfo() const { const ARMABIInfo &getABIInfo() const {
▲ Show 20 Lines • Show All 752 Lines • ▼ Show 20 Linespublic:
Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
QualType Ty) const override; QualType Ty) const override;
bool shouldPassIndirectlyForSwift(CharUnits totalSize, bool shouldPassIndirectlyForSwift(CharUnits totalSize,
ArrayRef<llvm::Type*> scalars, ArrayRef<llvm::Type*> scalars,
bool asReturnValue) const override { bool asReturnValue) const override {
return occupiesMoreThan(CGT, scalars, /*total*/ 4); return occupiesMoreThan(CGT, scalars, /*total*/ 4);
} }
bool isSwiftErrorInRegister() const override {
return true;
}
}; };
class SystemZTargetCodeGenInfo : public TargetCodeGenInfo { class SystemZTargetCodeGenInfo : public TargetCodeGenInfo {
public: public:
SystemZTargetCodeGenInfo(CodeGenTypes &CGT, bool HasVector) SystemZTargetCodeGenInfo(CodeGenTypes &CGT, bool HasVector)
: TargetCodeGenInfo(new SystemZABIInfo(CGT, HasVector)) {} : TargetCodeGenInfo(new SystemZABIInfo(CGT, HasVector)) {}
}; };
▲ Show 20 Lines • Show All 2,352 Lines • Show Last 20 Lines

lib/Driver/ToolChains.h

Show First 20 Lines • Show All 906 Lines • ▼ Show 20 Linespublic:
AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const override; llvm::opt::ArgStringList &CC1Args) const override;
void AddClangCXXStdlibIncludeArgs( void AddClangCXXStdlibIncludeArgs(
const llvm::opt::ArgList &Args, const llvm::opt::ArgList &Args,
llvm::opt::ArgStringList &CC1Args) const override; llvm::opt::ArgStringList &CC1Args) const override;
void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs, void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const override; llvm::opt::ArgStringList &CC1Args) const override;
SanitizerMask getSupportedSanitizers() const override;
const ToolChain &HostTC; const ToolChain &HostTC;
CudaInstallationDetector CudaInstallation; CudaInstallationDetector CudaInstallation;
protected: protected:
Tool *buildAssembler() const override; // ptxas Tool *buildAssembler() const override; // ptxas
Tool *buildLinker() const override; // fatbinary (ok, not really a linker) Tool *buildLinker() const override; // fatbinary (ok, not really a linker)
}; };
▲ Show 20 Lines • Show All 405 Lines • Show Last 20 Lines

lib/Driver/ToolChains.cpp

Show First 20 Lines • Show All 4,967 Lines • ▼ Show 20 Linesvoid CudaToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &Args,
HostTC.AddClangCXXStdlibIncludeArgs(Args, CC1Args); HostTC.AddClangCXXStdlibIncludeArgs(Args, CC1Args);
} }
void CudaToolChain::AddIAMCUIncludeArgs(const ArgList &Args, void CudaToolChain::AddIAMCUIncludeArgs(const ArgList &Args,
ArgStringList &CC1Args) const { ArgStringList &CC1Args) const {
HostTC.AddIAMCUIncludeArgs(Args, CC1Args); HostTC.AddIAMCUIncludeArgs(Args, CC1Args);
} }
SanitizerMask CudaToolChain::getSupportedSanitizers() const {
// The CudaToolChain only supports sanitizers in the sense that it allows
// sanitizer arguments on the command line if they are supported by the host
// toolchain. The CudaToolChain will actually ignore any command line
// arguments for any of these "supported" sanitizers. That means that no
// sanitization of device code is actually supported at this time.
//
// This behavior is necessary because the host and device toolchains
// invocations often share the command line, so the device toolchain must
// tolerate flags meant only for the host toolchain.
return HostTC.getSupportedSanitizers();
}
/// XCore tool chain /// XCore tool chain
XCoreToolChain::XCoreToolChain(const Driver &D, const llvm::Triple &Triple, XCoreToolChain::XCoreToolChain(const Driver &D, const llvm::Triple &Triple,
const ArgList &Args) const ArgList &Args)
: ToolChain(D, Triple, Args) { : ToolChain(D, Triple, Args) {
// ProgramPaths are found via 'PATH' environment variable. // ProgramPaths are found via 'PATH' environment variable.
} }
Tool *XCoreToolChain::buildAssembler() const { Tool *XCoreToolChain::buildAssembler() const {
▲ Show 20 Lines • Show All 292 Lines • Show Last 20 Lines

lib/Driver/Tools.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,109 Lines • ▼ Show 20 Lines for (StringRef Value : A->getValues()) {
} else { } else {
RenderDebugEnablingArgs(Args, CmdArgs, RenderDebugEnablingArgs(Args, CmdArgs,
codegenoptions::LimitedDebugInfo, codegenoptions::LimitedDebugInfo,
DwarfVersion, llvm::DebuggerKind::Default); DwarfVersion, llvm::DebuggerKind::Default);
} }
} else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") || } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") ||
Value.startswith("-mhwdiv") || Value.startswith("-march")) { Value.startswith("-mhwdiv") || Value.startswith("-march")) {
// Do nothing, we'll validate it later. // Do nothing, we'll validate it later.
} else if (Value == "-defsym") {
CmdArgs.push_back(Value.data());
TakeNextArg = true;
} else { } else {
D.Diag(diag::err_drv_unsupported_option_argument) D.Diag(diag::err_drv_unsupported_option_argument)
<< A->getOption().getName() << Value; << A->getOption().getName() << Value;
} }
} }
} }
if (CompressDebugSections) { if (CompressDebugSections) {
if (llvm::zlib::isAvailable()) if (llvm::zlib::isAvailable())
▲ Show 20 Lines • Show All 510 Lines • ▼ Show 20 Lines if (IsWindowsMSVC) {
// FIXME: Consider bumping this to 19 (MSVC2015) soon. // FIXME: Consider bumping this to 19 (MSVC2015) soon.
return VersionTuple(18); return VersionTuple(18);
} }
} }
return VersionTuple(); return VersionTuple();
} }
static Arg *getLastProfileUseArg(const ArgList &Args) {
auto *ProfileUseArg = Args.getLastArg(
options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
options::OPT_fno_profile_instr_use);
if (ProfileUseArg &&
ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
ProfileUseArg = nullptr;
return ProfileUseArg;
}
static void addPGOAndCoverageFlags(Compilation &C, const Driver &D, static void addPGOAndCoverageFlags(Compilation &C, const Driver &D,
const InputInfo &Output, const ArgList &Args, const InputInfo &Output, const ArgList &Args,
ArgStringList &CmdArgs) { ArgStringList &CmdArgs) {
auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate, auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
options::OPT_fprofile_generate_EQ, options::OPT_fprofile_generate_EQ,
options::OPT_fno_profile_generate); options::OPT_fno_profile_generate);
if (PGOGenerateArg && if (PGOGenerateArg &&
PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate)) PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
PGOGenerateArg = nullptr; PGOGenerateArg = nullptr;
auto *ProfileGenerateArg = Args.getLastArg( auto *ProfileGenerateArg = Args.getLastArg(
options::OPT_fprofile_instr_generate, options::OPT_fprofile_instr_generate,
options::OPT_fprofile_instr_generate_EQ, options::OPT_fprofile_instr_generate_EQ,
options::OPT_fno_profile_instr_generate); options::OPT_fno_profile_instr_generate);
if (ProfileGenerateArg && if (ProfileGenerateArg &&
ProfileGenerateArg->getOption().matches( ProfileGenerateArg->getOption().matches(
options::OPT_fno_profile_instr_generate)) options::OPT_fno_profile_instr_generate))
ProfileGenerateArg = nullptr; ProfileGenerateArg = nullptr;
if (PGOGenerateArg && ProfileGenerateArg) if (PGOGenerateArg && ProfileGenerateArg)
D.Diag(diag::err_drv_argument_not_allowed_with) D.Diag(diag::err_drv_argument_not_allowed_with)
<< PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling(); << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
auto *ProfileUseArg = Args.getLastArg( auto *ProfileUseArg = getLastProfileUseArg(Args);
options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
options::OPT_fno_profile_instr_use);
if (ProfileUseArg &&
ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
ProfileUseArg = nullptr;
if (PGOGenerateArg && ProfileUseArg) if (PGOGenerateArg && ProfileUseArg)
D.Diag(diag::err_drv_argument_not_allowed_with) D.Diag(diag::err_drv_argument_not_allowed_with)
<< ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling(); << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
if (ProfileGenerateArg && ProfileUseArg) if (ProfileGenerateArg && ProfileUseArg)
D.Diag(diag::err_drv_argument_not_allowed_with) D.Diag(diag::err_drv_argument_not_allowed_with)
<< ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling(); << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
▲ Show 20 Lines • Show All 4,745 Lines • ▼ Show 20 Lines if (Args.hasFlag(options::OPT_fsave_optimization_record,
CmdArgs.push_back("-mllvm"); CmdArgs.push_back("-mllvm");
CmdArgs.push_back("-lto-pass-remarks-output"); CmdArgs.push_back("-lto-pass-remarks-output");
CmdArgs.push_back("-mllvm"); CmdArgs.push_back("-mllvm");
SmallString<128> F; SmallString<128> F;
F = Output.getFilename(); F = Output.getFilename();
F += ".opt.yaml"; F += ".opt.yaml";
CmdArgs.push_back(Args.MakeArgString(F)); CmdArgs.push_back(Args.MakeArgString(F));
if (getLastProfileUseArg(Args)) {
CmdArgs.push_back("-mllvm");
CmdArgs.push_back("-lto-pass-remarks-with-hotness");
}
} }
// It seems that the 'e' option is completely ignored for dynamic executables // It seems that the 'e' option is completely ignored for dynamic executables
// (the default), and with static executables, the last one wins, as expected. // (the default), and with static executables, the last one wins, as expected.
Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t, Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
options::OPT_Z_Flag, options::OPT_u_Group, options::OPT_Z_Flag, options::OPT_u_Group,
options::OPT_e, options::OPT_r}); options::OPT_e, options::OPT_r});
▲ Show 20 Lines • Show All 3,664 Lines • Show Last 20 Lines

lib/Format/Format.cpp

Show First 20 Lines • Show All 1,508 Lines • ▼ Show 20 Linesinline bool isHeaderInsertion(const tooling::Replacement &Replace) {
return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 && return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
llvm::Regex(IncludeRegexPattern).match(Replace.getReplacementText()); llvm::Regex(IncludeRegexPattern).match(Replace.getReplacementText());
} }
inline bool isHeaderDeletion(const tooling::Replacement &Replace) { inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1; return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
} }
void skipComments(Lexer &Lex, Token &Tok) { // Returns the offset after skipping a sequence of tokens, matched by \p
while (Tok.is(tok::comment)) // GetOffsetAfterSequence, from the start of the code.
if (Lex.LexFromRawLexer(Tok)) // \p GetOffsetAfterSequence should be a function that matches a sequence of
return; // tokens and returns an offset after the sequence.
unsigned getOffsetAfterTokenSequence(
StringRef FileName, StringRef Code, const FormatStyle &Style,
std::function<unsigned(const SourceManager &, Lexer &, Token &)>
GetOffsetAfterSequense) {
std::unique_ptr<Environment> Env =
Environment::CreateVirtualEnvironment(Code, FileName, /*Ranges=*/{});
const SourceManager &SourceMgr = Env->getSourceManager();
Lexer Lex(Env->getFileID(), SourceMgr.getBuffer(Env->getFileID()), SourceMgr,
getFormattingLangOpts(Style));
Token Tok;
// Get the first token.
Lex.LexFromRawLexer(Tok);
return GetOffsetAfterSequense(SourceMgr, Lex, Tok);
} }
// Check if a sequence of tokens is like "#<Name> <raw_identifier>". If it is, // Check if a sequence of tokens is like "#<Name> <raw_identifier>". If it is,
// \p Tok will be the token after this directive; otherwise, it can be any token // \p Tok will be the token after this directive; otherwise, it can be any token
// after the given \p Tok (including \p Tok). // after the given \p Tok (including \p Tok).
bool checkAndConsumeDirectiveWithName(Lexer &Lex, StringRef Name, Token &Tok) { bool checkAndConsumeDirectiveWithName(Lexer &Lex, StringRef Name, Token &Tok) {
bool Matched = Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) && bool Matched = Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
Tok.is(tok::raw_identifier) && Tok.is(tok::raw_identifier) &&
Tok.getRawIdentifier() == Name && !Lex.LexFromRawLexer(Tok) && Tok.getRawIdentifier() == Name && !Lex.LexFromRawLexer(Tok) &&
Tok.is(tok::raw_identifier); tok::raw_identifier;
if (Matched) if (Matched)
Lex.LexFromRawLexer(Tok); Lex.LexFromRawLexer(Tok);
return Matched; return Matched;
} }
void skipComments(Lexer &Lex, Token &Tok) {
while (Tok.is(tok::comment))
if (Lex.LexFromRawLexer(Tok))
return;
}
// Returns the offset after header guard directives and any comments
// before/after header guards. If no header guard presents in the code, this
// will returns the offset after skipping all comments from the start of the
// code.
unsigned getOffsetAfterHeaderGuardsAndComments(StringRef FileName, unsigned getOffsetAfterHeaderGuardsAndComments(StringRef FileName,
StringRef Code, StringRef Code,
const FormatStyle &Style) { const FormatStyle &Style) {
std::unique_ptr<Environment> Env = return getOffsetAfterTokenSequence(
Environment::CreateVirtualEnvironment(Code, FileName, /*Ranges=*/{}); FileName, Code, Style,
const SourceManager &SourceMgr = Env->getSourceManager(); [](const SourceManager &SM, Lexer &Lex, Token Tok) {
Lexer Lex(Env->getFileID(), SourceMgr.getBuffer(Env->getFileID()), SourceMgr,
getFormattingLangOpts(Style));
Token Tok;
// Get the first token.
Lex.LexFromRawLexer(Tok);
skipComments(Lex, Tok); skipComments(Lex, Tok);
unsigned AfterComments = SourceMgr.getFileOffset(Tok.getLocation()); unsigned InitialOffset = SM.getFileOffset(Tok.getLocation());
if (checkAndConsumeDirectiveWithName(Lex, "ifndef", Tok)) { if (checkAndConsumeDirectiveWithName(Lex, "ifndef", Tok)) {
skipComments(Lex, Tok); skipComments(Lex, Tok);
if (checkAndConsumeDirectiveWithName(Lex, "define", Tok)) if (checkAndConsumeDirectiveWithName(Lex, "define", Tok))
return SourceMgr.getFileOffset(Tok.getLocation()); return SM.getFileOffset(Tok.getLocation());
} }
return AfterComments; return InitialOffset;
});
}
// Check if a sequence of tokens is like
// "#include ("header.h" | <header.h>)".
// If it is, \p Tok will be the token after this directive; otherwise, it can be
// any token after the given \p Tok (including \p Tok).
bool checkAndConsumeInclusiveDirective(Lexer &Lex, Token &Tok) {
auto Matched = [&]() {
Lex.LexFromRawLexer(Tok);
return true;
};
if (Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "include") {
if (Lex.LexFromRawLexer(Tok))
return false;
if (Tok.is(tok::string_literal))
return Matched();
if (Tok.is(tok::less)) {
while (!Lex.LexFromRawLexer(Tok) && Tok.isNot(tok::greater)) {
}
if (Tok.is(tok::greater))
return Matched();
}
}
return false;
}
// Returns the offset of the last #include directive after which a new
// #include can be inserted. This ignores #include's after the #include block(s)
// in the beginning of a file to avoid inserting headers into code sections
// where new #include's should not be added by default.
// These code sections include:
// - raw string literals (containing #include).
// - #if blocks.
// - Special #include's among declarations (e.g. functions).
//
// If no #include after which a new #include can be inserted, this returns the
// offset after skipping all comments from the start of the code.
// Inserting after an #include is not allowed if it comes after code that is not
// #include (e.g. pre-processing directive that is not #include, declarations).
unsigned getMaxHeaderInsertionOffset(StringRef FileName, StringRef Code,
const FormatStyle &Style) {
return getOffsetAfterTokenSequence(
FileName, Code, Style,
[](const SourceManager &SM, Lexer &Lex, Token Tok) {
skipComments(Lex, Tok);
unsigned MaxOffset = SM.getFileOffset(Tok.getLocation());
while (checkAndConsumeInclusiveDirective(Lex, Tok))
MaxOffset = SM.getFileOffset(Tok.getLocation());
return MaxOffset;
});
} }
bool isDeletedHeader(llvm::StringRef HeaderName, bool isDeletedHeader(llvm::StringRef HeaderName,
const std::set<llvm::StringRef> &HeadersToDelete) { const std::set<llvm::StringRef> &HeadersToDelete) {
return HeadersToDelete.count(HeaderName) || return HeadersToDelete.count(HeaderName) ||
HeadersToDelete.count(HeaderName.trim("\"<>")); HeadersToDelete.count(HeaderName.trim("\"<>"));
} }
// FIXME: we also need to insert a '\n' at the end of the code if we have an
// insertion with offset Code.size(), and there is no '\n' at the end of the
// code.
// FIXME: do not insert headers into conditional #include blocks, e.g. #includes
// surrounded by compile condition "#if...".
// FIXME: insert empty lines between newly created blocks. // FIXME: insert empty lines between newly created blocks.
tooling::Replacements tooling::Replacements
fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces, fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
const FormatStyle &Style) { const FormatStyle &Style) {
if (Style.Language != FormatStyle::LanguageKind::LK_Cpp) if (Style.Language != FormatStyle::LanguageKind::LK_Cpp)
return Replaces; return Replaces;
tooling::Replacements HeaderInsertions; tooling::Replacements HeaderInsertions;
Show All 31 LinesfixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
std::set<int> Priorities = {0, INT_MAX}; std::set<int> Priorities = {0, INT_MAX};
for (const auto &Category : Style.IncludeCategories) for (const auto &Category : Style.IncludeCategories)
Priorities.insert(Category.Priority); Priorities.insert(Category.Priority);
int FirstIncludeOffset = -1; int FirstIncludeOffset = -1;
// All new headers should be inserted after this offset. // All new headers should be inserted after this offset.
unsigned MinInsertOffset = unsigned MinInsertOffset =
getOffsetAfterHeaderGuardsAndComments(FileName, Code, Style); getOffsetAfterHeaderGuardsAndComments(FileName, Code, Style);
StringRef TrimmedCode = Code.drop_front(MinInsertOffset); StringRef TrimmedCode = Code.drop_front(MinInsertOffset);
unsigned MaxInsertOffset =
getMaxHeaderInsertionOffset(FileName, TrimmedCode, Style);
SmallVector<StringRef, 32> Lines; SmallVector<StringRef, 32> Lines;
TrimmedCode.split(Lines, '\n'); TrimmedCode.split(Lines, '\n');
unsigned Offset = MinInsertOffset; unsigned Offset = MinInsertOffset;
unsigned NextLineOffset; unsigned NextLineOffset;
std::set<StringRef> ExistingIncludes; std::set<StringRef> ExistingIncludes;
for (auto Line : Lines) { for (auto Line : Lines) {
NextLineOffset = std::min(Code.size(), Offset + Line.size() + 1); NextLineOffset = std::min(Code.size(), Offset + Line.size() + 1);
if (IncludeRegex.match(Line, &Matches)) { if (IncludeRegex.match(Line, &Matches)) {
// The header name with quotes or angle brackets. // The header name with quotes or angle brackets.
StringRef IncludeName = Matches[2]; StringRef IncludeName = Matches[2];
ExistingIncludes.insert(IncludeName); ExistingIncludes.insert(IncludeName);
// Only record the offset of current #include if we can insert after it.
if (Offset <= MaxInsertOffset) {
int Category = Categories.getIncludePriority( int Category = Categories.getIncludePriority(
IncludeName, /*CheckMainHeader=*/FirstIncludeOffset < 0); IncludeName, /*CheckMainHeader=*/FirstIncludeOffset < 0);
CategoryEndOffsets[Category] = NextLineOffset; CategoryEndOffsets[Category] = NextLineOffset;
if (FirstIncludeOffset < 0) if (FirstIncludeOffset < 0)
FirstIncludeOffset = Offset; FirstIncludeOffset = Offset;
}
if (isDeletedHeader(IncludeName, HeadersToDelete)) { if (isDeletedHeader(IncludeName, HeadersToDelete)) {
// If this is the last line without trailing newline, we need to make // If this is the last line without trailing newline, we need to make
// sure we don't delete across the file boundary. // sure we don't delete across the file boundary.
unsigned Length = std::min(Line.size() + 1, Code.size() - Offset); unsigned Length = std::min(Line.size() + 1, Code.size() - Offset);
llvm::Error Err = llvm::Error Err =
Result.add(tooling::Replacement(FileName, Offset, Length, "")); Result.add(tooling::Replacement(FileName, Offset, Length, ""));
if (Err) { if (Err) {
// Ignore the deletion on conflict. // Ignore the deletion on conflict.
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

lib/Frontend/InitHeaderSearch.cpp

Show First 20 Lines • Show All 520 Lines • ▼ Show 20 Lines for (unsigned i = First; i != SearchList.size(); ++i) {
// ignore the user's request and drop the user dir... keeping the system // ignore the user's request and drop the user dir... keeping the system
// dir. This is weird, but required to emulate GCC's search path correctly. // dir. This is weird, but required to emulate GCC's search path correctly.
// //
// Since dupes of system dirs are rare, just rescan to find the original // Since dupes of system dirs are rare, just rescan to find the original
// that we're nuking instead of using a DenseMap. // that we're nuking instead of using a DenseMap.
if (CurEntry.getDirCharacteristic() != SrcMgr::C_User) { if (CurEntry.getDirCharacteristic() != SrcMgr::C_User) {
// Find the dir that this is the same of. // Find the dir that this is the same of.
unsigned FirstDir; unsigned FirstDir;
for (FirstDir = 0; ; ++FirstDir) { for (FirstDir = First;; ++FirstDir) {
assert(FirstDir != i && "Didn't find dupe?"); assert(FirstDir != i && "Didn't find dupe?");
const DirectoryLookup &SearchEntry = SearchList[FirstDir]; const DirectoryLookup &SearchEntry = SearchList[FirstDir];
// If these are different lookup types, then they can't be the dupe. // If these are different lookup types, then they can't be the dupe.
if (SearchEntry.getLookupType() != CurEntry.getLookupType()) if (SearchEntry.getLookupType() != CurEntry.getLookupType())
continue; continue;
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

lib/Frontend/InitPreprocessor.cpp

Show First 20 Lines • Show All 504 Lines • ▼ Show 20 Linesstatic void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
} }
if (LangOpts.SizedDeallocation) if (LangOpts.SizedDeallocation)
Builder.defineMacro("__cpp_sized_deallocation", "201309"); Builder.defineMacro("__cpp_sized_deallocation", "201309");
// C++17 features. // C++17 features.
if (LangOpts.CPlusPlus1z) { if (LangOpts.CPlusPlus1z) {
Builder.defineMacro("__cpp_hex_float", "201603"); Builder.defineMacro("__cpp_hex_float", "201603");
Builder.defineMacro("__cpp_inline_variables", "201606"); Builder.defineMacro("__cpp_inline_variables", "201606");
//Builder.defineMacro("__cpp_noexcept_function_type", "201510"); Builder.defineMacro("__cpp_noexcept_function_type", "201510");
Builder.defineMacro("__cpp_capture_star_this", "201603"); Builder.defineMacro("__cpp_capture_star_this", "201603");
Builder.defineMacro("__cpp_if_constexpr", "201606"); Builder.defineMacro("__cpp_if_constexpr", "201606");
Builder.defineMacro("__cpp_template_auto", "201606"); Builder.defineMacro("__cpp_template_auto", "201606");
Builder.defineMacro("__cpp_namespace_attributes", "201411"); Builder.defineMacro("__cpp_namespace_attributes", "201411");
Builder.defineMacro("__cpp_enumerator_attributes", "201411"); Builder.defineMacro("__cpp_enumerator_attributes", "201411");
Builder.defineMacro("__cpp_nested_namespace_definitions", "201411"); Builder.defineMacro("__cpp_nested_namespace_definitions", "201411");
Builder.defineMacro("__cpp_aggregate_bases", "201603"); Builder.defineMacro("__cpp_aggregate_bases", "201603");
Builder.defineMacro("__cpp_nontype_template_args", "201411"); Builder.defineMacro("__cpp_nontype_template_args", "201411");
▲ Show 20 Lines • Show All 579 Lines • Show Last 20 Lines

lib/Parse/ParseDecl.cpp

Show First 20 Lines • Show All 4,186 Lines • ▼ Show 20 Linesvoid Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
ParseScope EnumScope(this, Scope::DeclScope | Scope::EnumScope); ParseScope EnumScope(this, Scope::DeclScope | Scope::EnumScope);
Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl); Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
BalancedDelimiterTracker T(*this, tok::l_brace); BalancedDelimiterTracker T(*this, tok::l_brace);
T.consumeOpen(); T.consumeOpen();
// C does not allow an empty enumerator-list, C++ does [dcl.enum]. // C does not allow an empty enumerator-list, C++ does [dcl.enum].
if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus) if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus)
Diag(Tok, diag::error_empty_enum); Diag(Tok, diag::err_empty_enum);
SmallVector<Decl *, 32> EnumConstantDecls; SmallVector<Decl *, 32> EnumConstantDecls;
SmallVector<SuppressAccessChecks, 32> EnumAvailabilityDiags; SmallVector<SuppressAccessChecks, 32> EnumAvailabilityDiags;
Decl *LastEnumConstDecl = nullptr; Decl *LastEnumConstDecl = nullptr;
// Parse the enumerator-list. // Parse the enumerator-list.
while (Tok.isNot(tok::r_brace)) { while (Tok.isNot(tok::r_brace)) {
▲ Show 20 Lines • Show All 2,329 Lines • Show Last 20 Lines

lib/Parse/ParseStmtAsm.cpp

Show First 20 Lines • Show All 675 Lines • ▼ Show 20 LinesStmtResult Parser::ParseAsmStatement(bool &msAsm) {
} }
DeclSpec DS(AttrFactory); DeclSpec DS(AttrFactory);
SourceLocation Loc = Tok.getLocation(); SourceLocation Loc = Tok.getLocation();
ParseTypeQualifierListOpt(DS, AR_VendorAttributesParsed); ParseTypeQualifierListOpt(DS, AR_VendorAttributesParsed);
// GNU asms accept, but warn, about type-qualifiers other than volatile. // GNU asms accept, but warn, about type-qualifiers other than volatile.
if (DS.getTypeQualifiers() & DeclSpec::TQ_const) if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
Diag(Loc, diag::w_asm_qualifier_ignored) << "const"; Diag(Loc, diag::warn_asm_qualifier_ignored) << "const";
if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict) if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
Diag(Loc, diag::w_asm_qualifier_ignored) << "restrict"; Diag(Loc, diag::warn_asm_qualifier_ignored) << "restrict";
// FIXME: Once GCC supports _Atomic, check whether it permits it here. // FIXME: Once GCC supports _Atomic, check whether it permits it here.
if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
Diag(Loc, diag::w_asm_qualifier_ignored) << "_Atomic"; Diag(Loc, diag::warn_asm_qualifier_ignored) << "_Atomic";
// Remember if this was a volatile asm. // Remember if this was a volatile asm.
bool isVolatile = DS.getTypeQualifiers() & DeclSpec::TQ_volatile; bool isVolatile = DS.getTypeQualifiers() & DeclSpec::TQ_volatile;
// TODO: support "asm goto" constructs (PR#9295). // TODO: support "asm goto" constructs (PR#9295).
if (Tok.is(tok::kw_goto)) { if (Tok.is(tok::kw_goto)) {
Diag(Tok, diag::err_asm_goto_not_supported_yet); Diag(Tok, diag::err_asm_goto_not_supported_yet);
SkipUntil(tok::r_paren, StopAtSemi); SkipUntil(tok::r_paren, StopAtSemi);
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

lib/Sema/Sema.cpp

Show First 20 Lines • Show All 384 Lines • ▼ Show 20 Lines#endif
diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getLocStart()); diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getLocStart());
QualType ExprTy = Context.getCanonicalType(E->getType()); QualType ExprTy = Context.getCanonicalType(E->getType());
QualType TypeTy = Context.getCanonicalType(Ty); QualType TypeTy = Context.getCanonicalType(Ty);
if (ExprTy == TypeTy) if (ExprTy == TypeTy)
return E; return E;
// C++1z [conv.array]: The temporary materialization conversion is applied.
// We also use this to fuel C++ DR1213, which applies to C++11 onwards.
if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
E->getValueKind() == VK_RValue) {
// The temporary is an lvalue in C++98 and an xvalue otherwise.
ExprResult Materialized = CreateMaterializeTemporaryExpr(
E->getType(), E, !getLangOpts().CPlusPlus11);
if (Materialized.isInvalid())
return ExprError();
E = Materialized.get();
}
if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) { if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) { if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
ImpCast->setType(Ty); ImpCast->setType(Ty);
ImpCast->setValueKind(VK); ImpCast->setValueKind(VK);
return E; return E;
} }
} }
▲ Show 20 Lines • Show All 1,132 Lines • Show Last 20 Lines

lib/Sema/SemaCast.cpp

Show First 20 Lines • Show All 2,435 Lines • ▼ Show 20 Lines if (!DestType->isScalarType() && !DestType->isVectorType()) {
if (Self.getLangOpts().OpenCL && DestType->isEventT()) { if (Self.getLangOpts().OpenCL && DestType->isEventT()) {
llvm::APSInt CastInt; llvm::APSInt CastInt;
if (SrcExpr.get()->EvaluateAsInt(CastInt, Self.Context)) { if (SrcExpr.get()->EvaluateAsInt(CastInt, Self.Context)) {
if (0 == CastInt) { if (0 == CastInt) {
Kind = CK_ZeroToOCLEvent; Kind = CK_ZeroToOCLEvent;
return; return;
} }
Self.Diag(OpRange.getBegin(), Self.Diag(OpRange.getBegin(),
diag::error_opencl_cast_non_zero_to_event_t) diag::err_opencl_cast_non_zero_to_event_t)
<< CastInt.toString(10) << SrcExpr.get()->getSourceRange(); << CastInt.toString(10) << SrcExpr.get()->getSourceRange();
SrcExpr = ExprError(); SrcExpr = ExprError();
return; return;
} }
} }
// Reject any other conversions to non-scalar types. // Reject any other conversions to non-scalar types.
Self.Diag(OpRange.getBegin(), diag::err_typecheck_cond_expect_scalar) Self.Diag(OpRange.getBegin(), diag::err_typecheck_cond_expect_scalar)
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

lib/Sema/SemaDeclCXX.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,094 Lines • ▼ Show 20 Lines
} }
void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD) { void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD) {
const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>(); const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
if (FPT->getExceptionSpecType() != EST_Unevaluated) if (FPT->getExceptionSpecType() != EST_Unevaluated)
return; return;
// Evaluate the exception specification. // Evaluate the exception specification.
auto ESI = computeImplicitExceptionSpec(*this, Loc, MD).getExceptionSpec(); auto IES = computeImplicitExceptionSpec(*this, Loc, MD);
auto ESI = IES.getExceptionSpec();
// Update the type of the special member to use it. // Update the type of the special member to use it.
UpdateExceptionSpec(MD, ESI); UpdateExceptionSpec(MD, ESI);
// A user-provided destructor can be defined outside the class. When that // A user-provided destructor can be defined outside the class. When that
// happens, be sure to update the exception specification on both // happens, be sure to update the exception specification on both
// declarations. // declarations.
const FunctionProtoType *CanonicalFPT = const FunctionProtoType *CanonicalFPT =
▲ Show 20 Lines • Show All 181 Lines • ▼ Show 20 Linesvoid Sema::CheckExplicitlyDefaultedMemberExceptionSpec(
if (SpecifiedType->getExceptionSpecType() == EST_Unparsed) if (SpecifiedType->getExceptionSpecType() == EST_Unparsed)
SpecifiedType = SpecifiedType =
MD->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>(); MD->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>();
// Compute the implicit exception specification. // Compute the implicit exception specification.
CallingConv CC = Context.getDefaultCallingConvention(/*IsVariadic=*/false, CallingConv CC = Context.getDefaultCallingConvention(/*IsVariadic=*/false,
/*IsCXXMethod=*/true); /*IsCXXMethod=*/true);
FunctionProtoType::ExtProtoInfo EPI(CC); FunctionProtoType::ExtProtoInfo EPI(CC);
EPI.ExceptionSpec = computeImplicitExceptionSpec(*this, MD->getLocation(), MD) auto IES = computeImplicitExceptionSpec(*this, MD->getLocation(), MD);
.getExceptionSpec(); EPI.ExceptionSpec = IES.getExceptionSpec();
const FunctionProtoType *ImplicitType = cast<FunctionProtoType>( const FunctionProtoType *ImplicitType = cast<FunctionProtoType>(
Context.getFunctionType(Context.VoidTy, None, EPI)); Context.getFunctionType(Context.VoidTy, None, EPI));
// Ensure that it matches. // Ensure that it matches.
CheckEquivalentExceptionSpec( CheckEquivalentExceptionSpec(
PDiag(diag::err_incorrect_defaulted_exception_spec) PDiag(diag::err_incorrect_defaulted_exception_spec)
<< getSpecialMember(MD), PDiag(), << getSpecialMember(MD), PDiag(),
ImplicitType, SourceLocation(), ImplicitType, SourceLocation(),
▲ Show 20 Lines • Show All 8,544 Lines • Show Last 20 Lines

lib/Sema/SemaDeclObjC.cpp

Show First 20 Lines • Show All 203 Lines • ▼ Show 20 Linesbool Sema::CheckARCMethodDecl(ObjCMethodDecl *method) {
case OMF_initialize: case OMF_initialize:
case OMF_performSelector: case OMF_performSelector:
return false; return false;
case OMF_dealloc: case OMF_dealloc:
if (!Context.hasSameType(method->getReturnType(), Context.VoidTy)) { if (!Context.hasSameType(method->getReturnType(), Context.VoidTy)) {
SourceRange ResultTypeRange = method->getReturnTypeSourceRange(); SourceRange ResultTypeRange = method->getReturnTypeSourceRange();
if (ResultTypeRange.isInvalid()) if (ResultTypeRange.isInvalid())
Diag(method->getLocation(), diag::error_dealloc_bad_result_type) Diag(method->getLocation(), diag::err_dealloc_bad_result_type)
<< method->getReturnType() << method->getReturnType()
<< FixItHint::CreateInsertion(method->getSelectorLoc(0), "(void)"); << FixItHint::CreateInsertion(method->getSelectorLoc(0), "(void)");
else else
Diag(method->getLocation(), diag::error_dealloc_bad_result_type) Diag(method->getLocation(), diag::err_dealloc_bad_result_type)
<< method->getReturnType() << method->getReturnType()
<< FixItHint::CreateReplacement(ResultTypeRange, "void"); << FixItHint::CreateReplacement(ResultTypeRange, "void");
return true; return true;
} }
return false; return false;
case OMF_init: case OMF_init:
// If the method doesn't obey the init rules, don't bother annotating it. // If the method doesn't obey the init rules, don't bother annotating it.
▲ Show 20 Lines • Show All 4,087 Lines • ▼ Show 20 LinesDecl *Sema::ActOnMethodDeclaration(
// optional arguments. The number of types/arguments is obtained // optional arguments. The number of types/arguments is obtained
// from the Sel.getNumArgs(). // from the Sel.getNumArgs().
ObjCArgInfo *ArgInfo, ObjCArgInfo *ArgInfo,
DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, // c-style args DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, // c-style args
AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind, AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind,
bool isVariadic, bool MethodDefinition) { bool isVariadic, bool MethodDefinition) {
// Make sure we can establish a context for the method. // Make sure we can establish a context for the method.
if (!CurContext->isObjCContainer()) { if (!CurContext->isObjCContainer()) {
Diag(MethodLoc, diag::error_missing_method_context); Diag(MethodLoc, diag::err_missing_method_context);
return nullptr; return nullptr;
} }
ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext); ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
Decl *ClassDecl = cast<Decl>(OCD); Decl *ClassDecl = cast<Decl>(OCD);
QualType resultDeclType; QualType resultDeclType;
bool HasRelatedResultType = false; bool HasRelatedResultType = false;
TypeSourceInfo *ReturnTInfo = nullptr; TypeSourceInfo *ReturnTInfo = nullptr;
▲ Show 20 Lines • Show All 485 Lines • Show Last 20 Lines

lib/Sema/SemaExceptionSpec.cpp

Show First 20 Lines • Show All 938 Lines • ▼ Show 20 Lines for (const Stmt *SubStmt : E->children()) {
R = mergeCanThrow(R, S.canThrow(cast<Expr>(SubStmt))); R = mergeCanThrow(R, S.canThrow(cast<Expr>(SubStmt)));
if (R == CT_Can) if (R == CT_Can)
break; break;
} }
return R; return R;
} }
static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) { static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) {
assert(D && "Expected decl");
// See if we can get a function type from the decl somehow.
const ValueDecl *VD = dyn_cast<ValueDecl>(D);
if (!VD) {
// In C++17, we may have a canonical exception specification. If so, use it.
if (auto *FT = E->getType().getCanonicalType()->getAs<FunctionProtoType>())
return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can;
// If we have no clue what we're calling, assume the worst.
return CT_Can;
}
// As an extension, we assume that __attribute__((nothrow)) functions don't // As an extension, we assume that __attribute__((nothrow)) functions don't
// throw. // throw.
if (isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>()) if (D && isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
return CT_Cannot; return CT_Cannot;
QualType T = VD->getType(); QualType T;
// In C++1z, just look at the function type of the callee.
if (S.getLangOpts().CPlusPlus1z && isa<CallExpr>(E)) {
E = cast<CallExpr>(E)->getCallee();
T = E->getType();
if (T->isSpecificPlaceholderType(BuiltinType::BoundMember)) {
// Sadly we don't preserve the actual type as part of the "bound member"
// placeholder, so we need to reconstruct it.
E = E->IgnoreParenImpCasts();
// Could be a call to a pointer-to-member or a plain member access.
if (auto *Op = dyn_cast<BinaryOperator>(E)) {
assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI);
T = Op->getRHS()->getType()
->castAs<MemberPointerType>()->getPointeeType();
} else {
T = cast<MemberExpr>(E)->getMemberDecl()->getType();
}
}
} else if (const ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D))
T = VD->getType();
else
// If we have no clue what we're calling, assume the worst.
return CT_Can;
const FunctionProtoType *FT; const FunctionProtoType *FT;
if ((FT = T->getAs<FunctionProtoType>())) { if ((FT = T->getAs<FunctionProtoType>())) {
} else if (const PointerType *PT = T->getAs<PointerType>()) } else if (const PointerType *PT = T->getAs<PointerType>())
FT = PT->getPointeeType()->getAs<FunctionProtoType>(); FT = PT->getPointeeType()->getAs<FunctionProtoType>();
else if (const ReferenceType *RT = T->getAs<ReferenceType>()) else if (const ReferenceType *RT = T->getAs<ReferenceType>())
FT = RT->getPointeeType()->getAs<FunctionProtoType>(); FT = RT->getPointeeType()->getAs<FunctionProtoType>();
else if (const MemberPointerType *MT = T->getAs<MemberPointerType>()) else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
FT = MT->getPointeeType()->getAs<FunctionProtoType>(); FT = MT->getPointeeType()->getAs<FunctionProtoType>();
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 LinesCanThrowResult Sema::canThrow(const Expr *E) {
case Expr::CXXOperatorCallExprClass: case Expr::CXXOperatorCallExprClass:
case Expr::UserDefinedLiteralClass: { case Expr::UserDefinedLiteralClass: {
const CallExpr *CE = cast<CallExpr>(E); const CallExpr *CE = cast<CallExpr>(E);
CanThrowResult CT; CanThrowResult CT;
if (E->isTypeDependent()) if (E->isTypeDependent())
CT = CT_Dependent; CT = CT_Dependent;
else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
CT = CT_Cannot; CT = CT_Cannot;
else if (CE->getCalleeDecl())
CT = canCalleeThrow(*this, E, CE->getCalleeDecl());
else else
CT = CT_Can; CT = canCalleeThrow(*this, E, CE->getCalleeDecl());
if (CT == CT_Can) if (CT == CT_Can)
return CT; return CT;
return mergeCanThrow(CT, canSubExprsThrow(*this, E)); return mergeCanThrow(CT, canSubExprsThrow(*this, E));
} }
case Expr::CXXConstructExprClass: case Expr::CXXConstructExprClass:
case Expr::CXXTemporaryObjectExprClass: { case Expr::CXXTemporaryObjectExprClass: {
CanThrowResult CT = canCalleeThrow(*this, E, CanThrowResult CT = canCalleeThrow(*this, E,
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

lib/Sema/SemaExpr.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,446 Lines • ▼ Show 20 LinesSema::LookupInObjCMethod(LookupResult &Lookup, Scope *S,
ObjCInterfaceDecl *IFace = nullptr; ObjCInterfaceDecl *IFace = nullptr;
if (LookForIvars) { if (LookForIvars) {
IFace = CurMethod->getClassInterface(); IFace = CurMethod->getClassInterface();
ObjCInterfaceDecl *ClassDeclared; ObjCInterfaceDecl *ClassDeclared;
ObjCIvarDecl *IV = nullptr; ObjCIvarDecl *IV = nullptr;
if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) { if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) {
// Diagnose using an ivar in a class method. // Diagnose using an ivar in a class method.
if (IsClassMethod) if (IsClassMethod)
return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) return ExprError(Diag(Loc, diag::err_ivar_use_in_class_method)
<< IV->getDeclName()); << IV->getDeclName());
// If we're referencing an invalid decl, just return this as a silent // If we're referencing an invalid decl, just return this as a silent
// error node. The error diagnostic was already emitted on the decl. // error node. The error diagnostic was already emitted on the decl.
if (IV->isInvalidDecl()) if (IV->isInvalidDecl())
return ExprError(); return ExprError();
// Check if referencing a field with __attribute__((deprecated)). // Check if referencing a field with __attribute__((deprecated)).
if (DiagnoseUseOfDecl(IV, Loc)) if (DiagnoseUseOfDecl(IV, Loc))
return ExprError(); return ExprError();
// Diagnose the use of an ivar outside of the declaring class. // Diagnose the use of an ivar outside of the declaring class.
if (IV->getAccessControl() == ObjCIvarDecl::Private && if (IV->getAccessControl() == ObjCIvarDecl::Private &&
!declaresSameEntity(ClassDeclared, IFace) && !declaresSameEntity(ClassDeclared, IFace) &&
!getLangOpts().DebuggerSupport) !getLangOpts().DebuggerSupport)
Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName(); Diag(Loc, diag::err_private_ivar_access) << IV->getDeclName();
// FIXME: This should use a new expr for a direct reference, don't // FIXME: This should use a new expr for a direct reference, don't
// turn this into Self->ivar, just return a BareIVarExpr or something. // turn this into Self->ivar, just return a BareIVarExpr or something.
IdentifierInfo &II = Context.Idents.get("self"); IdentifierInfo &II = Context.Idents.get("self");
UnqualifiedId SelfName; UnqualifiedId SelfName;
SelfName.setIdentifier(&II, SourceLocation()); SelfName.setIdentifier(&II, SourceLocation());
SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam); SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam);
CXXScopeSpec SelfScopeSpec; CXXScopeSpec SelfScopeSpec;
Show All 39 Lines if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) {
declaresSameEntity(IFace, ClassDeclared)) declaresSameEntity(IFace, ClassDeclared))
Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName(); Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
} }
} }
} else if (Lookup.isSingleResult() && } else if (Lookup.isSingleResult() &&
Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()) { Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()) {
// If accessing a stand-alone ivar in a class method, this is an error. // If accessing a stand-alone ivar in a class method, this is an error.
if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl())) if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl()))
return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) return ExprError(Diag(Loc, diag::err_ivar_use_in_class_method)
<< IV->getDeclName()); << IV->getDeclName());
} }
if (Lookup.empty() && II && AllowBuiltinCreation) { if (Lookup.empty() && II && AllowBuiltinCreation) {
// FIXME. Consolidate this with similar code in LookupName. // FIXME. Consolidate this with similar code in LookupName.
if (unsigned BuiltinID = II->getBuiltinID()) { if (unsigned BuiltinID = II->getBuiltinID()) {
if (!(getLangOpts().CPlusPlus && if (!(getLangOpts().CPlusPlus &&
Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) { Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) {
▲ Show 20 Lines • Show All 1,835 Lines • ▼ Show 20 Lines
} }
ExprResult ExprResult
Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
Expr *Idx, SourceLocation RLoc) { Expr *Idx, SourceLocation RLoc) {
Expr *LHSExp = Base; Expr *LHSExp = Base;
Expr *RHSExp = Idx; Expr *RHSExp = Idx;
ExprValueKind VK = VK_LValue;
ExprObjectKind OK = OK_Ordinary;
// Per C++ core issue 1213, the result is an xvalue if either operand is
// a non-lvalue array, and an lvalue otherwise.
if (getLangOpts().CPlusPlus11 &&
((LHSExp->getType()->isArrayType() && !LHSExp->isLValue()) ||
(RHSExp->getType()->isArrayType() && !RHSExp->isLValue())))
VK = VK_XValue;
// Perform default conversions. // Perform default conversions.
if (!LHSExp->getType()->getAs<VectorType>()) { if (!LHSExp->getType()->getAs<VectorType>()) {
ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp); ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp);
if (Result.isInvalid()) if (Result.isInvalid())
return ExprError(); return ExprError();
LHSExp = Result.get(); LHSExp = Result.get();
} }
ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp); ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp);
if (Result.isInvalid()) if (Result.isInvalid())
return ExprError(); return ExprError();
RHSExp = Result.get(); RHSExp = Result.get();
QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
ExprValueKind VK = VK_LValue;
ExprObjectKind OK = OK_Ordinary;
// C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
// to the expression *((e1)+(e2)). This means the array "Base" may actually be // to the expression *((e1)+(e2)). This means the array "Base" may actually be
// in the subscript position. As a result, we need to derive the array base // in the subscript position. As a result, we need to derive the array base
// and index from the expression types. // and index from the expression types.
Expr *BaseExpr, *IndexExpr; Expr *BaseExpr, *IndexExpr;
QualType ResultType; QualType ResultType;
if (LHSTy->isDependentType() || RHSTy->isDependentType()) { if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
▲ Show 20 Lines • Show All 1,180 Lines • ▼ Show 20 Lines if (isFileScope &&
!LiteralExpr->isTypeDependent() && !LiteralExpr->isTypeDependent() &&
!LiteralExpr->isValueDependent() && !LiteralExpr->isValueDependent() &&
!literalType->isDependentType()) { // 6.5.2.5p3 !literalType->isDependentType()) { // 6.5.2.5p3
if (CheckForConstantInitializer(LiteralExpr, literalType)) if (CheckForConstantInitializer(LiteralExpr, literalType))
return ExprError(); return ExprError();
} }
// In C, compound literals are l-values for some reason. // In C, compound literals are l-values for some reason.
ExprValueKind VK = getLangOpts().CPlusPlus ? VK_RValue : VK_LValue; // For GCC compatibility, in C++, file-scope array compound literals with
// constant initializers are also l-values, and compound literals are
// otherwise prvalues.
//
// (GCC also treats C++ list-initialized file-scope array prvalues with
// constant initializers as l-values, but that's non-conforming, so we don't
// follow it there.)
//
// FIXME: It would be better to handle the lvalue cases as materializing and
// lifetime-extending a temporary object, but our materialized temporaries
// representation only supports lifetime extension from a variable, not "out
// of thin air".
// FIXME: For C++, we might want to instead lifetime-extend only if a pointer
// is bound to the result of applying array-to-pointer decay to the compound
// literal.
// FIXME: GCC supports compound literals of reference type, which should
// obviously have a value kind derived from the kind of reference involved.
ExprValueKind VK =
(getLangOpts().CPlusPlus && !(isFileScope && literalType->isArrayType()))
? VK_RValue
: VK_LValue;
return MaybeBindToTemporary( return MaybeBindToTemporary(
new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
VK, LiteralExpr, isFileScope)); VK, LiteralExpr, isFileScope));
} }
ExprResult ExprResult
Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
SourceLocation RBraceLoc) { SourceLocation RBraceLoc) {
// Immediately handle non-overload placeholders. Overloads can be // Immediately handle non-overload placeholders. Overloads can be
// resolved contextually, but everything else here can't. // resolved contextually, but everything else here can't.
for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) { for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
▲ Show 20 Lines • Show All 4,202 Lines • ▼ Show 20 Linesinline QualType Sema::CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS,
// The result is a bool. // The result is a bool.
return Context.BoolTy; return Context.BoolTy;
} }
static bool IsReadonlyMessage(Expr *E, Sema &S) { static bool IsReadonlyMessage(Expr *E, Sema &S) {
const MemberExpr *ME = dyn_cast<MemberExpr>(E); const MemberExpr *ME = dyn_cast<MemberExpr>(E);
if (!ME) return false; if (!ME) return false;
if (!isa<FieldDecl>(ME->getMemberDecl())) return false; if (!isa<FieldDecl>(ME->getMemberDecl())) return false;
ObjCMessageExpr *Base = ObjCMessageExpr *Base = dyn_cast<ObjCMessageExpr>(
dyn_cast<ObjCMessageExpr>(ME->getBase()->IgnoreParenImpCasts()); ME->getBase()->IgnoreImplicit()->IgnoreParenImpCasts());
if (!Base) return false; if (!Base) return false;
return Base->getMethodDecl() != nullptr; return Base->getMethodDecl() != nullptr;
} }
/// Is the given expression (which must be 'const') a reference to a /// Is the given expression (which must be 'const') a reference to a
/// variable which was originally non-const, but which has become /// variable which was originally non-const, but which has become
/// 'const' due to being captured within a block? /// 'const' due to being captured within a block?
enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda }; enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda };
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Linesstatic void DiagnoseConstAssignment(Sema &S, const Expr *E,
// next checked expression is the result of a dereference. // next checked expression is the result of a dereference.
bool IsDereference = false; bool IsDereference = false;
bool NextIsDereference = false; bool NextIsDereference = false;
// Loop to process MemberExpr chains. // Loop to process MemberExpr chains.
while (true) { while (true) {
IsDereference = NextIsDereference; IsDereference = NextIsDereference;
E = E->IgnoreParenImpCasts(); E = E->IgnoreImplicit()->IgnoreParenImpCasts();
if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
NextIsDereference = ME->isArrow(); NextIsDereference = ME->isArrow();
const ValueDecl *VD = ME->getMemberDecl(); const ValueDecl *VD = ME->getMemberDecl();
if (const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) { if (const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
// Mutable fields can be modified even if the class is const. // Mutable fields can be modified even if the class is const.
if (Field->isMutable()) { if (Field->isMutable()) {
assert(DiagnosticEmitted && "Expected diagnostic not emitted."); assert(DiagnosticEmitted && "Expected diagnostic not emitted.");
break; break;
▲ Show 20 Lines • Show All 181 Lines • ▼ Show 20 Lines case Expr::MLV_IncompleteVoidType:
return S.RequireCompleteType(Loc, E->getType(), return S.RequireCompleteType(Loc, E->getType(),
diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E); diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
case Expr::MLV_DuplicateVectorComponents: case Expr::MLV_DuplicateVectorComponents:
DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue; DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
break; break;
case Expr::MLV_NoSetterProperty: case Expr::MLV_NoSetterProperty:
llvm_unreachable("readonly properties should be processed differently"); llvm_unreachable("readonly properties should be processed differently");
case Expr::MLV_InvalidMessageExpression: case Expr::MLV_InvalidMessageExpression:
DiagID = diag::error_readonly_message_assignment; DiagID = diag::err_readonly_message_assignment;
break; break;
case Expr::MLV_SubObjCPropertySetting: case Expr::MLV_SubObjCPropertySetting:
DiagID = diag::error_no_subobject_property_setting; DiagID = diag::err_no_subobject_property_setting;
break; break;
} }
SourceRange Assign; SourceRange Assign;
if (Loc != OrigLoc) if (Loc != OrigLoc)
Assign = SourceRange(OrigLoc, OrigLoc); Assign = SourceRange(OrigLoc, OrigLoc);
if (NeedType) if (NeedType)
S.Diag(Loc, DiagID) << E->getType() << E->getSourceRange() << Assign; S.Diag(Loc, DiagID) << E->getType() << E->getSourceRange() << Assign;
▲ Show 20 Lines • Show All 2,649 Lines • ▼ Show 20 Linesbool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); } if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); }
if (MayHaveFunctionDiff) if (MayHaveFunctionDiff)
HandleFunctionTypeMismatch(FDiag, SecondType, FirstType); HandleFunctionTypeMismatch(FDiag, SecondType, FirstType);
Diag(Loc, FDiag); Diag(Loc, FDiag);
if (DiagKind == diag::warn_incompatible_qualified_id && if (DiagKind == diag::warn_incompatible_qualified_id &&
PDecl && IFace && !IFace->hasDefinition()) PDecl && IFace && !IFace->hasDefinition())
Diag(IFace->getLocation(), diag::not_incomplete_class_and_qualified_id) Diag(IFace->getLocation(), diag::note_incomplete_class_and_qualified_id)
<< IFace->getName() << PDecl->getName(); << IFace->getName() << PDecl->getName();
if (SecondType == Context.OverloadTy) if (SecondType == Context.OverloadTy)
NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression, NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression,
FirstType, /*TakingAddress=*/true); FirstType, /*TakingAddress=*/true);
if (CheckInferredResultType) if (CheckInferredResultType)
EmitRelatedResultTypeNote(SrcExpr); EmitRelatedResultTypeNote(SrcExpr);
▲ Show 20 Lines • Show All 2,544 Lines • Show Last 20 Lines

lib/Sema/SemaExprCXX.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,978 Lines • ▼ Show 20 Lines
QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS,
ExprValueKind &VK, ExprValueKind &VK,
SourceLocation Loc, SourceLocation Loc,
bool isIndirect) { bool isIndirect) {
assert(!LHS.get()->getType()->isPlaceholderType() && assert(!LHS.get()->getType()->isPlaceholderType() &&
!RHS.get()->getType()->isPlaceholderType() && !RHS.get()->getType()->isPlaceholderType() &&
"placeholders should have been weeded out by now"); "placeholders should have been weeded out by now");
// The LHS undergoes lvalue conversions if this is ->*. // The LHS undergoes lvalue conversions if this is ->*, and undergoes the
if (isIndirect) { // temporary materialization conversion otherwise.
if (isIndirect)
LHS = DefaultLvalueConversion(LHS.get()); LHS = DefaultLvalueConversion(LHS.get());
if (LHS.isInvalid()) return QualType(); else if (LHS.get()->isRValue())
} LHS = TemporaryMaterializationConversion(LHS.get());
if (LHS.isInvalid())
return QualType();
// The RHS always undergoes lvalue conversions. // The RHS always undergoes lvalue conversions.
RHS = DefaultLvalueConversion(RHS.get()); RHS = DefaultLvalueConversion(RHS.get());
if (RHS.isInvalid()) return QualType(); if (RHS.isInvalid()) return QualType();
const char *OpSpelling = isIndirect ? "->*" : ".*"; const char *OpSpelling = isIndirect ? "->*" : ".*";
// C++ 5.5p2 // C++ 5.5p2
// The binary operator .* [p3: ->*] binds its second operand, which shall // The binary operator .* [p3: ->*] binds its second operand, which shall
▲ Show 20 Lines • Show All 2,467 Lines • Show Last 20 Lines

lib/Sema/SemaExprMember.cpp

Show First 20 Lines • Show All 963 Lines • ▼ Show 20 LinesSema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType,
bool SuppressQualifierCheck, bool SuppressQualifierCheck,
ActOnMemberAccessExtraArgs *ExtraArgs) { ActOnMemberAccessExtraArgs *ExtraArgs) {
QualType BaseType = BaseExprType; QualType BaseType = BaseExprType;
if (IsArrow) { if (IsArrow) {
assert(BaseType->isPointerType()); assert(BaseType->isPointerType());
BaseType = BaseType->castAs<PointerType>()->getPointeeType(); BaseType = BaseType->castAs<PointerType>()->getPointeeType();
} }
R.setBaseObjectType(BaseType); R.setBaseObjectType(BaseType);
// C++1z [expr.ref]p2:
// For the first option (dot) the first expression shall be a glvalue [...]
if (!IsArrow && BaseExpr->isRValue()) {
ExprResult Converted = TemporaryMaterializationConversion(BaseExpr);
if (Converted.isInvalid())
return ExprError();
BaseExpr = Converted.get();
}
LambdaScopeInfo *const CurLSI = getCurLambda(); LambdaScopeInfo *const CurLSI = getCurLambda();
// If this is an implicit member reference and the overloaded // If this is an implicit member reference and the overloaded
// name refers to both static and non-static member functions // name refers to both static and non-static member functions
// (i.e. BaseExpr is null) and if we are currently processing a lambda, // (i.e. BaseExpr is null) and if we are currently processing a lambda,
// check if we should/can capture 'this'... // check if we should/can capture 'this'...
// Keep this example in mind: // Keep this example in mind:
// struct X { // struct X {
// void f(int) { } // void f(int) { }
▲ Show 20 Lines • Show All 470 Lines • ▼ Show 20 Lines if (IV->getAccessControl() != ObjCIvarDecl::Public &&
else if (ObjCCategoryImplDecl* CatImplClass = else if (ObjCCategoryImplDecl* CatImplClass =
dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl)) dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl))
ClassOfMethodDecl = CatImplClass->getClassInterface(); ClassOfMethodDecl = CatImplClass->getClassInterface();
} }
if (!S.getLangOpts().DebuggerSupport) { if (!S.getLangOpts().DebuggerSupport) {
if (IV->getAccessControl() == ObjCIvarDecl::Private) { if (IV->getAccessControl() == ObjCIvarDecl::Private) {
if (!declaresSameEntity(ClassDeclared, IDecl) || if (!declaresSameEntity(ClassDeclared, IDecl) ||
!declaresSameEntity(ClassOfMethodDecl, ClassDeclared)) !declaresSameEntity(ClassOfMethodDecl, ClassDeclared))
S.Diag(MemberLoc, diag::error_private_ivar_access) S.Diag(MemberLoc, diag::err_private_ivar_access)
<< IV->getDeclName(); << IV->getDeclName();
} else if (!IDecl->isSuperClassOf(ClassOfMethodDecl)) } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))
// @protected // @protected
S.Diag(MemberLoc, diag::error_protected_ivar_access) S.Diag(MemberLoc, diag::err_protected_ivar_access)
<< IV->getDeclName(); << IV->getDeclName();
} }
} }
bool warn = true; bool warn = true;
if (S.getLangOpts().ObjCAutoRefCount) { if (S.getLangOpts().ObjCAutoRefCount) {
Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts(); Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts();
if (UnaryOperator *UO = dyn_cast<UnaryOperator>(BaseExp)) if (UnaryOperator *UO = dyn_cast<UnaryOperator>(BaseExp))
if (UO->getOpcode() == UO_Deref) if (UO->getOpcode() == UO_Deref)
BaseExp = UO->getSubExpr()->IgnoreParenCasts(); BaseExp = UO->getSubExpr()->IgnoreParenCasts();
if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp)) if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp))
if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) { if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
S.Diag(DE->getLocation(), diag::error_arc_weak_ivar_access); S.Diag(DE->getLocation(), diag::err_arc_weak_ivar_access);
warn = false; warn = false;
} }
} }
if (warn) { if (warn) {
if (ObjCMethodDecl *MD = S.getCurMethodDecl()) { if (ObjCMethodDecl *MD = S.getCurMethodDecl()) {
ObjCMethodFamily MF = MD->getMethodFamily(); ObjCMethodFamily MF = MD->getMethodFamily();
warn = (MF != OMF_init && MF != OMF_dealloc && warn = (MF != OMF_init && MF != OMF_dealloc &&
MF != OMF_finalize && MF != OMF_finalize &&
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

lib/Sema/SemaExprObjC.cpp

Show First 20 Lines • Show All 1,106 Lines • ▼ Show 20 Lines for (M = M->getNext(); M; M=M->getNext()) {
if (MatchingMethodDecl == Method || if (MatchingMethodDecl == Method ||
isa<ObjCImplDecl>(MatchingMethodDecl->getDeclContext()) || isa<ObjCImplDecl>(MatchingMethodDecl->getDeclContext()) ||
MatchingMethodDecl->getSelector() != Method->getSelector()) MatchingMethodDecl->getSelector() != Method->getSelector())
continue; continue;
if (!S.MatchTwoMethodDeclarations(Method, if (!S.MatchTwoMethodDeclarations(Method,
MatchingMethodDecl, Sema::MMS_loose)) { MatchingMethodDecl, Sema::MMS_loose)) {
if (!Warned) { if (!Warned) {
Warned = true; Warned = true;
S.Diag(AtLoc, diag::warning_multiple_selectors) S.Diag(AtLoc, diag::warn_multiple_selectors)
<< Method->getSelector() << FixItHint::CreateInsertion(LParenLoc, "(") << Method->getSelector() << FixItHint::CreateInsertion(LParenLoc, "(")
<< FixItHint::CreateInsertion(RParenLoc, ")"); << FixItHint::CreateInsertion(RParenLoc, ")");
S.Diag(Method->getLocation(), diag::note_method_declared_at) S.Diag(Method->getLocation(), diag::note_method_declared_at)
<< Method->getDeclName(); << Method->getDeclName();
} }
S.Diag(MatchingMethodDecl->getLocation(), diag::note_method_declared_at) S.Diag(MatchingMethodDecl->getLocation(), diag::note_method_declared_at)
<< MatchingMethodDecl->getDeclName(); << MatchingMethodDecl->getDeclName();
} }
} }
return Warned; return Warned;
} }
static void DiagnoseMismatchedSelectors(Sema &S, SourceLocation AtLoc, static void DiagnoseMismatchedSelectors(Sema &S, SourceLocation AtLoc,
ObjCMethodDecl *Method, ObjCMethodDecl *Method,
SourceLocation LParenLoc, SourceLocation LParenLoc,
SourceLocation RParenLoc, SourceLocation RParenLoc,
bool WarnMultipleSelectors) { bool WarnMultipleSelectors) {
if (!WarnMultipleSelectors || if (!WarnMultipleSelectors ||
S.Diags.isIgnored(diag::warning_multiple_selectors, SourceLocation())) S.Diags.isIgnored(diag::warn_multiple_selectors, SourceLocation()))
return; return;
bool Warned = false; bool Warned = false;
for (Sema::GlobalMethodPool::iterator b = S.MethodPool.begin(), for (Sema::GlobalMethodPool::iterator b = S.MethodPool.begin(),
e = S.MethodPool.end(); b != e; b++) { e = S.MethodPool.end(); b != e; b++) {
// first, instance methods // first, instance methods
ObjCMethodList &InstMethList = b->second.first; ObjCMethodList &InstMethList = b->second.first;
if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc, if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc,
Method, InstMethList)) Method, InstMethList))
▲ Show 20 Lines • Show All 386 Lines • ▼ Show 20 Lines if (getLangOpts().ObjCAutoRefCount)
DiagID = diag::err_arc_method_not_found; DiagID = diag::err_arc_method_not_found;
else else
DiagID = isClassMessage ? diag::warn_class_method_not_found DiagID = isClassMessage ? diag::warn_class_method_not_found
: diag::warn_inst_method_not_found; : diag::warn_inst_method_not_found;
if (!getLangOpts().DebuggerSupport) { if (!getLangOpts().DebuggerSupport) {
const ObjCMethodDecl *OMD = SelectorsForTypoCorrection(Sel, ReceiverType); const ObjCMethodDecl *OMD = SelectorsForTypoCorrection(Sel, ReceiverType);
if (OMD && !OMD->isInvalidDecl()) { if (OMD && !OMD->isInvalidDecl()) {
if (getLangOpts().ObjCAutoRefCount) if (getLangOpts().ObjCAutoRefCount)
DiagID = diag::error_method_not_found_with_typo; DiagID = diag::err_method_not_found_with_typo;
else else
DiagID = isClassMessage ? diag::warn_class_method_not_found_with_typo DiagID = isClassMessage ? diag::warn_class_method_not_found_with_typo
: diag::warn_instance_method_not_found_with_typo; : diag::warn_instance_method_not_found_with_typo;
Selector MatchedSel = OMD->getSelector(); Selector MatchedSel = OMD->getSelector();
SourceRange SelectorRange(SelectorLocs.front(), SelectorLocs.back()); SourceRange SelectorRange(SelectorLocs.front(), SelectorLocs.back());
if (MatchedSel.isUnarySelector()) if (MatchedSel.isUnarySelector())
Diag(SelLoc, DiagID) Diag(SelLoc, DiagID)
<< Sel<< isClassMessage << MatchedSel << Sel<< isClassMessage << MatchedSel
▲ Show 20 Lines • Show All 405 Lines • ▼ Show 20 Lines if (!IFace) {
// property reference. // property reference.
if (receiverNamePtr->isStr("super")) { if (receiverNamePtr->isStr("super")) {
if (ObjCMethodDecl *CurMethod = tryCaptureObjCSelf(receiverNameLoc)) { if (ObjCMethodDecl *CurMethod = tryCaptureObjCSelf(receiverNameLoc)) {
if (auto classDecl = CurMethod->getClassInterface()) { if (auto classDecl = CurMethod->getClassInterface()) {
SuperType = QualType(classDecl->getSuperClassType(), 0); SuperType = QualType(classDecl->getSuperClassType(), 0);
if (CurMethod->isInstanceMethod()) { if (CurMethod->isInstanceMethod()) {
if (SuperType.isNull()) { if (SuperType.isNull()) {
// The current class does not have a superclass. // The current class does not have a superclass.
Diag(receiverNameLoc, diag::error_root_class_cannot_use_super) Diag(receiverNameLoc, diag::err_root_class_cannot_use_super)
<< CurMethod->getClassInterface()->getIdentifier(); << CurMethod->getClassInterface()->getIdentifier();
return ExprError(); return ExprError();
} }
QualType T = Context.getObjCObjectPointerType(SuperType); QualType T = Context.getObjCObjectPointerType(SuperType);
return HandleExprPropertyRefExpr(T->castAs<ObjCObjectPointerType>(), return HandleExprPropertyRefExpr(T->castAs<ObjCObjectPointerType>(),
/*BaseExpr*/nullptr, /*BaseExpr*/nullptr,
SourceLocation()/*OpLoc*/, SourceLocation()/*OpLoc*/,
▲ Show 20 Lines • Show All 192 Lines • ▼ Show 20 LinesExprResult Sema::ActOnSuperMessage(Scope *S,
ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc); ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc);
if (!Method) { if (!Method) {
Diag(SuperLoc, diag::err_invalid_receiver_to_message_super); Diag(SuperLoc, diag::err_invalid_receiver_to_message_super);
return ExprError(); return ExprError();
} }
ObjCInterfaceDecl *Class = Method->getClassInterface(); ObjCInterfaceDecl *Class = Method->getClassInterface();
if (!Class) { if (!Class) {
Diag(SuperLoc, diag::error_no_super_class_message) Diag(SuperLoc, diag::err_no_super_class_message)
<< Method->getDeclName(); << Method->getDeclName();
return ExprError(); return ExprError();
} }
QualType SuperTy(Class->getSuperClassType(), 0); QualType SuperTy(Class->getSuperClassType(), 0);
if (SuperTy.isNull()) { if (SuperTy.isNull()) {
// The current class does not have a superclass. // The current class does not have a superclass.
Diag(SuperLoc, diag::error_root_class_cannot_use_super) Diag(SuperLoc, diag::err_root_class_cannot_use_super)
<< Class->getIdentifier(); << Class->getIdentifier();
return ExprError(); return ExprError();
} }
// We are in a method whose class has a superclass, so 'super' // We are in a method whose class has a superclass, so 'super'
// is acting as a keyword. // is acting as a keyword.
if (Method->getSelector() == Sel) if (Method->getSelector() == Sel)
getCurFunction()->ObjCShouldCallSuper = false; getCurFunction()->ObjCShouldCallSuper = false;
▲ Show 20 Lines • Show All 2,173 Lines • Show Last 20 Lines

lib/Sema/SemaInit.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,957 Lines • ▼ Show 20 Lines if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
if (ILE->getNumInits() == 1 && ILE->isGLValue()) { if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
// This is just redundant braces around an initializer. Step over it. // This is just redundant braces around an initializer. Step over it.
Init = ILE->getInit(0); Init = ILE->getInit(0);
} }
} }
// Step over any subobject adjustments; we may have a materialized // Step over any subobject adjustments; we may have a materialized
// temporary inside them. // temporary inside them.
SmallVector<const Expr *, 2> CommaLHSs; Init = const_cast<Expr *>(Init->skipRValueSubobjectAdjustments());
SmallVector<SubobjectAdjustment, 2> Adjustments;
Init = const_cast<Expr *>(
Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
// Per current approach for DR1376, look through casts to reference type // Per current approach for DR1376, look through casts to reference type
// when performing lifetime extension. // when performing lifetime extension.
if (CastExpr *CE = dyn_cast<CastExpr>(Init)) if (CastExpr *CE = dyn_cast<CastExpr>(Init))
if (CE->getSubExpr()->isGLValue()) if (CE->getSubExpr()->isGLValue())
Init = CE->getSubExpr(); Init = CE->getSubExpr();
// FIXME: Per DR1213, subscripting on an array temporary produces an xvalue. // Per the current approach for DR1299, look through array element access
// It's unclear if binding a reference to that xvalue extends the array // when performing lifetime extension.
// temporary. if (auto *ASE = dyn_cast<ArraySubscriptExpr>(Init))
Init = ASE->getBase();
} while (Init != Old); } while (Init != Old);
if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) { if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
// Update the storage duration of the materialized temporary. // Update the storage duration of the materialized temporary.
// FIXME: Rebuild the expression instead of mutating it. // FIXME: Rebuild the expression instead of mutating it.
ME->setExtendingDecl(ExtendingEntity->getDecl(), ME->setExtendingDecl(ExtendingEntity->getDecl(),
ExtendingEntity->allocateManglingNumber()); ExtendingEntity->allocateManglingNumber());
performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingEntity); performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingEntity);
return true; return true;
} }
return false; return false;
} }
/// Update a prvalue expression that is going to be materialized as a /// Update a prvalue expression that is going to be materialized as a
/// lifetime-extended temporary. /// lifetime-extended temporary.
static void performLifetimeExtension(Expr *Init, static void performLifetimeExtension(Expr *Init,
const InitializedEntity *ExtendingEntity) { const InitializedEntity *ExtendingEntity) {
// Dig out the expression which constructs the extended temporary. // Dig out the expression which constructs the extended temporary.
SmallVector<const Expr *, 2> CommaLHSs; Init = const_cast<Expr *>(Init->skipRValueSubobjectAdjustments());
SmallVector<SubobjectAdjustment, 2> Adjustments;
Init = const_cast<Expr *>(
Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init)) if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
Init = BTE->getSubExpr(); Init = BTE->getSubExpr();
if (CXXStdInitializerListExpr *ILE = if (CXXStdInitializerListExpr *ILE =
dyn_cast<CXXStdInitializerListExpr>(Init)) { dyn_cast<CXXStdInitializerListExpr>(Init)) {
performReferenceExtension(ILE->getSubExpr(), ExtendingEntity); performReferenceExtension(ILE->getSubExpr(), ExtendingEntity);
return; return;
▲ Show 20 Lines • Show All 202 Lines • ▼ Show 20 LinesSema::CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
// TODO: It'll be good to have a single place to check the access of the // TODO: It'll be good to have a single place to check the access of the
// destructor and generate ExprWithCleanups for various uses. Currently these // destructor and generate ExprWithCleanups for various uses. Currently these
// are done in both CreateMaterializeTemporaryExpr and MaybeBindToTemporary, // are done in both CreateMaterializeTemporaryExpr and MaybeBindToTemporary,
// but there may be a chance to merge them. // but there may be a chance to merge them.
Cleanup.setExprNeedsCleanups(false); Cleanup.setExprNeedsCleanups(false);
return MTE; return MTE;
} }
ExprResult Sema::TemporaryMaterializationConversion(Expr *E) {
// In C++98, we don't want to implicitly create an xvalue.
// FIXME: This means that AST consumers need to deal with "prvalues" that
// denote materialized temporaries. Maybe we should add another ValueKind
// for "xvalue pretending to be a prvalue" for C++98 support.
if (!E->isRValue() || !getLangOpts().CPlusPlus11)
return E;
// C++1z [conv.rval]/1: T shall be a complete type.
QualType T = E->getType();
if (RequireCompleteType(E->getExprLoc(), T, diag::err_incomplete_type))
return ExprError();
return CreateMaterializeTemporaryExpr(E->getType(), E, false);
}
ExprResult ExprResult
InitializationSequence::Perform(Sema &S, InitializationSequence::Perform(Sema &S,
const InitializedEntity &Entity, const InitializedEntity &Entity,
const InitializationKind &Kind, const InitializationKind &Kind,
MultiExprArg Args, MultiExprArg Args,
QualType *ResultType) { QualType *ResultType) {
if (Failed()) { if (Failed()) {
Diagnose(S, Entity, Kind, Args); Diagnose(S, Entity, Kind, Args);
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
<< Init->getSourceRange(); << Init->getSourceRange();
} }
// Diagnose cases where we initialize a pointer to an array temporary, and the // Diagnose cases where we initialize a pointer to an array temporary, and the
// pointer obviously outlives the temporary. // pointer obviously outlives the temporary.
if (Args.size() == 1 && Args[0]->getType()->isArrayType() && if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Entity.getType()->isPointerType() && Entity.getType()->isPointerType() &&
InitializedEntityOutlivesFullExpression(Entity)) { InitializedEntityOutlivesFullExpression(Entity)) {
Expr *Init = Args[0]; const Expr *Init = Args[0]->skipRValueSubobjectAdjustments();
if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
Init = MTE->GetTemporaryExpr();
Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context); Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary) if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay) S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
<< Init->getSourceRange(); << Init->getSourceRange();
} }
QualType DestType = Entity.getType().getNonReferenceType(); QualType DestType = Entity.getType().getNonReferenceType();
// FIXME: Ugly hack around the fact that Entity.getType() is not // FIXME: Ugly hack around the fact that Entity.getType() is not
▲ Show 20 Lines • Show All 1,623 Lines • Show Last 20 Lines

lib/Sema/SemaObjCProperty.cpp

Show First 20 Lines • Show All 747 Lines • ▼ Show 20 Linesstatic void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc,
case Qualifiers::OCL_Strong: case Qualifiers::OCL_Strong:
S.Diag(ivar->getLocation(), diag::err_arc_strong_property_ownership) S.Diag(ivar->getLocation(), diag::err_arc_strong_property_ownership)
<< property->getDeclName() << property->getDeclName()
<< ivar->getDeclName() << ivar->getDeclName()
<< ivarLifetime; << ivarLifetime;
break; break;
case Qualifiers::OCL_Weak: case Qualifiers::OCL_Weak:
S.Diag(ivar->getLocation(), diag::error_weak_property) S.Diag(ivar->getLocation(), diag::err_weak_property)
<< property->getDeclName() << property->getDeclName()
<< ivar->getDeclName(); << ivar->getDeclName();
break; break;
case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_ExplicitNone:
S.Diag(ivar->getLocation(), diag::err_arc_assign_property_ownership) S.Diag(ivar->getLocation(), diag::err_arc_assign_property_ownership)
<< property->getDeclName() << property->getDeclName()
<< ivar->getDeclName() << ivar->getDeclName()
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 LinesDecl *Sema::ActOnPropertyImplDecl(Scope *S,
IdentifierInfo *PropertyId, IdentifierInfo *PropertyId,
IdentifierInfo *PropertyIvar, IdentifierInfo *PropertyIvar,
SourceLocation PropertyIvarLoc, SourceLocation PropertyIvarLoc,
ObjCPropertyQueryKind QueryKind) { ObjCPropertyQueryKind QueryKind) {
ObjCContainerDecl *ClassImpDecl = ObjCContainerDecl *ClassImpDecl =
dyn_cast<ObjCContainerDecl>(CurContext); dyn_cast<ObjCContainerDecl>(CurContext);
// Make sure we have a context for the property implementation declaration. // Make sure we have a context for the property implementation declaration.
if (!ClassImpDecl) { if (!ClassImpDecl) {
Diag(AtLoc, diag::error_missing_property_context); Diag(AtLoc, diag::err_missing_property_context);
return nullptr; return nullptr;
} }
if (PropertyIvarLoc.isInvalid()) if (PropertyIvarLoc.isInvalid())
PropertyIvarLoc = PropertyLoc; PropertyIvarLoc = PropertyLoc;
SourceLocation PropertyDiagLoc = PropertyLoc; SourceLocation PropertyDiagLoc = PropertyLoc;
if (PropertyDiagLoc.isInvalid()) if (PropertyDiagLoc.isInvalid())
PropertyDiagLoc = ClassImpDecl->getLocStart(); PropertyDiagLoc = ClassImpDecl->getLocStart();
ObjCPropertyDecl *property = nullptr; ObjCPropertyDecl *property = nullptr;
ObjCInterfaceDecl *IDecl = nullptr; ObjCInterfaceDecl *IDecl = nullptr;
// Find the class or category class where this property must have // Find the class or category class where this property must have
// a declaration. // a declaration.
ObjCImplementationDecl *IC = nullptr; ObjCImplementationDecl *IC = nullptr;
ObjCCategoryImplDecl *CatImplClass = nullptr; ObjCCategoryImplDecl *CatImplClass = nullptr;
if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) { if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {
IDecl = IC->getClassInterface(); IDecl = IC->getClassInterface();
// We always synthesize an interface for an implementation // We always synthesize an interface for an implementation
// without an interface decl. So, IDecl is always non-zero. // without an interface decl. So, IDecl is always non-zero.
assert(IDecl && assert(IDecl &&
"ActOnPropertyImplDecl - @implementation without @interface"); "ActOnPropertyImplDecl - @implementation without @interface");
// Look for this property declaration in the @implementation's @interface // Look for this property declaration in the @implementation's @interface
property = IDecl->FindPropertyDeclaration(PropertyId, QueryKind); property = IDecl->FindPropertyDeclaration(PropertyId, QueryKind);
if (!property) { if (!property) {
Diag(PropertyLoc, diag::error_bad_property_decl) << IDecl->getDeclName(); Diag(PropertyLoc, diag::err_bad_property_decl) << IDecl->getDeclName();
return nullptr; return nullptr;
} }
if (property->isClassProperty() && Synthesize) { if (property->isClassProperty() && Synthesize) {
Diag(PropertyLoc, diag::error_synthesize_on_class_property) << PropertyId; Diag(PropertyLoc, diag::err_synthesize_on_class_property) << PropertyId;
return nullptr; return nullptr;
} }
unsigned PIkind = property->getPropertyAttributesAsWritten(); unsigned PIkind = property->getPropertyAttributesAsWritten();
if ((PIkind & (ObjCPropertyDecl::OBJC_PR_atomic | if ((PIkind & (ObjCPropertyDecl::OBJC_PR_atomic |
ObjCPropertyDecl::OBJC_PR_nonatomic) ) == 0) { ObjCPropertyDecl::OBJC_PR_nonatomic) ) == 0) {
if (AtLoc.isValid()) if (AtLoc.isValid())
Diag(AtLoc, diag::warn_implicit_atomic_property); Diag(AtLoc, diag::warn_implicit_atomic_property);
else else
Diag(IC->getLocation(), diag::warn_auto_implicit_atomic_property); Diag(IC->getLocation(), diag::warn_auto_implicit_atomic_property);
Diag(property->getLocation(), diag::note_property_declare); Diag(property->getLocation(), diag::note_property_declare);
} }
if (const ObjCCategoryDecl *CD = if (const ObjCCategoryDecl *CD =
dyn_cast<ObjCCategoryDecl>(property->getDeclContext())) { dyn_cast<ObjCCategoryDecl>(property->getDeclContext())) {
if (!CD->IsClassExtension()) { if (!CD->IsClassExtension()) {
Diag(PropertyLoc, diag::error_category_property) << CD->getDeclName(); Diag(PropertyLoc, diag::err_category_property) << CD->getDeclName();
Diag(property->getLocation(), diag::note_property_declare); Diag(property->getLocation(), diag::note_property_declare);
return nullptr; return nullptr;
} }
} }
if (Synthesize&& if (Synthesize&&
(PIkind & ObjCPropertyDecl::OBJC_PR_readonly) && (PIkind & ObjCPropertyDecl::OBJC_PR_readonly) &&
property->hasAttr<IBOutletAttr>() && property->hasAttr<IBOutletAttr>() &&
!AtLoc.isValid()) { !AtLoc.isValid()) {
Show All 27 Lines if (Synthesize&&
} }
} }
} }
if (Synthesize && isa<ObjCProtocolDecl>(property->getDeclContext())) if (Synthesize && isa<ObjCProtocolDecl>(property->getDeclContext()))
DiagnosePropertyMismatchDeclInProtocols(*this, AtLoc, IDecl, property); DiagnosePropertyMismatchDeclInProtocols(*this, AtLoc, IDecl, property);
} else if ((CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassImpDecl))) { } else if ((CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassImpDecl))) {
if (Synthesize) { if (Synthesize) {
Diag(AtLoc, diag::error_synthesize_category_decl); Diag(AtLoc, diag::err_synthesize_category_decl);
return nullptr; return nullptr;
} }
IDecl = CatImplClass->getClassInterface(); IDecl = CatImplClass->getClassInterface();
if (!IDecl) { if (!IDecl) {
Diag(AtLoc, diag::error_missing_property_interface); Diag(AtLoc, diag::err_missing_property_interface);
return nullptr; return nullptr;
} }
ObjCCategoryDecl *Category = ObjCCategoryDecl *Category =
IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier()); IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier());
// If category for this implementation not found, it is an error which // If category for this implementation not found, it is an error which
// has already been reported eralier. // has already been reported eralier.
if (!Category) if (!Category)
return nullptr; return nullptr;
// Look for this property declaration in @implementation's category // Look for this property declaration in @implementation's category
property = Category->FindPropertyDeclaration(PropertyId, QueryKind); property = Category->FindPropertyDeclaration(PropertyId, QueryKind);
if (!property) { if (!property) {
Diag(PropertyLoc, diag::error_bad_category_property_decl) Diag(PropertyLoc, diag::err_bad_category_property_decl)
<< Category->getDeclName(); << Category->getDeclName();
return nullptr; return nullptr;
} }
} else { } else {
Diag(AtLoc, diag::error_bad_property_context); Diag(AtLoc, diag::err_bad_property_context);
return nullptr; return nullptr;
} }
ObjCIvarDecl *Ivar = nullptr; ObjCIvarDecl *Ivar = nullptr;
bool CompleteTypeErr = false; bool CompleteTypeErr = false;
bool compat = true; bool compat = true;
// Check that we have a valid, previously declared ivar for @synthesize // Check that we have a valid, previously declared ivar for @synthesize
if (Synthesize) { if (Synthesize) {
// @synthesize // @synthesize
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Lines if (!Ivar) {
Diag(property->getLocation(), diag::note_property_declare); Diag(property->getLocation(), diag::note_property_declare);
Ivar->setInvalidDecl(); Ivar->setInvalidDecl();
} else if (CompleteTypeErr) } else if (CompleteTypeErr)
Ivar->setInvalidDecl(); Ivar->setInvalidDecl();
ClassImpDecl->addDecl(Ivar); ClassImpDecl->addDecl(Ivar);
IDecl->makeDeclVisibleInContext(Ivar); IDecl->makeDeclVisibleInContext(Ivar);
if (getLangOpts().ObjCRuntime.isFragile()) if (getLangOpts().ObjCRuntime.isFragile())
Diag(PropertyDiagLoc, diag::error_missing_property_ivar_decl) Diag(PropertyDiagLoc, diag::err_missing_property_ivar_decl)
<< PropertyId; << PropertyId;
// Note! I deliberately want it to fall thru so, we have a // Note! I deliberately want it to fall thru so, we have a
// a property implementation and to avoid future warnings. // a property implementation and to avoid future warnings.
} else if (getLangOpts().ObjCRuntime.isNonFragile() && } else if (getLangOpts().ObjCRuntime.isNonFragile() &&
!declaresSameEntity(ClassDeclared, IDecl)) { !declaresSameEntity(ClassDeclared, IDecl)) {
Diag(PropertyDiagLoc, diag::error_ivar_in_superclass_use) Diag(PropertyDiagLoc, diag::err_ivar_in_superclass_use)
<< property->getDeclName() << Ivar->getDeclName() << property->getDeclName() << Ivar->getDeclName()
<< ClassDeclared->getDeclName(); << ClassDeclared->getDeclName();
Diag(Ivar->getLocation(), diag::note_previous_access_declaration) Diag(Ivar->getLocation(), diag::note_previous_access_declaration)
<< Ivar << Ivar->getName(); << Ivar << Ivar->getName();
// Note! I deliberately want it to fall thru so more errors are caught. // Note! I deliberately want it to fall thru so more errors are caught.
} }
property->setPropertyIvarDecl(Ivar); property->setPropertyIvarDecl(Ivar);
QualType IvarType = Context.getCanonicalType(Ivar->getType()); QualType IvarType = Context.getCanonicalType(Ivar->getType());
// Check that type of property and its ivar are type compatible. // Check that type of property and its ivar are type compatible.
if (!Context.hasSameType(PropertyIvarType, IvarType)) { if (!Context.hasSameType(PropertyIvarType, IvarType)) {
if (isa<ObjCObjectPointerType>(PropertyIvarType) if (isa<ObjCObjectPointerType>(PropertyIvarType)
&& isa<ObjCObjectPointerType>(IvarType)) && isa<ObjCObjectPointerType>(IvarType))
compat = compat =
Context.canAssignObjCInterfaces( Context.canAssignObjCInterfaces(
PropertyIvarType->getAs<ObjCObjectPointerType>(), PropertyIvarType->getAs<ObjCObjectPointerType>(),
IvarType->getAs<ObjCObjectPointerType>()); IvarType->getAs<ObjCObjectPointerType>());
else { else {
compat = (CheckAssignmentConstraints(PropertyIvarLoc, PropertyIvarType, compat = (CheckAssignmentConstraints(PropertyIvarLoc, PropertyIvarType,
IvarType) IvarType)
== Compatible); == Compatible);
} }
if (!compat) { if (!compat) {
Diag(PropertyDiagLoc, diag::error_property_ivar_type) Diag(PropertyDiagLoc, diag::err_property_ivar_type)
<< property->getDeclName() << PropType << property->getDeclName() << PropType
<< Ivar->getDeclName() << IvarType; << Ivar->getDeclName() << IvarType;
Diag(Ivar->getLocation(), diag::note_ivar_decl); Diag(Ivar->getLocation(), diag::note_ivar_decl);
// Note! I deliberately want it to fall thru so, we have a // Note! I deliberately want it to fall thru so, we have a
// a property implementation and to avoid future warnings. // a property implementation and to avoid future warnings.
} }
else { else {
// FIXME! Rules for properties are somewhat different that those // FIXME! Rules for properties are somewhat different that those
// for assignments. Use a new routine to consolidate all cases; // for assignments. Use a new routine to consolidate all cases;
// specifically for property redeclarations as well as for ivars. // specifically for property redeclarations as well as for ivars.
QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType(); QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType();
QualType rhsType =Context.getCanonicalType(IvarType).getUnqualifiedType(); QualType rhsType =Context.getCanonicalType(IvarType).getUnqualifiedType();
if (lhsType != rhsType && if (lhsType != rhsType &&
lhsType->isArithmeticType()) { lhsType->isArithmeticType()) {
Diag(PropertyDiagLoc, diag::error_property_ivar_type) Diag(PropertyDiagLoc, diag::err_property_ivar_type)
<< property->getDeclName() << PropType << property->getDeclName() << PropType
<< Ivar->getDeclName() << IvarType; << Ivar->getDeclName() << IvarType;
Diag(Ivar->getLocation(), diag::note_ivar_decl); Diag(Ivar->getLocation(), diag::note_ivar_decl);
// Fall thru - see previous comment // Fall thru - see previous comment
} }
} }
// __weak is explicit. So it works on Canonical type. // __weak is explicit. So it works on Canonical type.
if ((PropType.isObjCGCWeak() && !IvarType.isObjCGCWeak() && if ((PropType.isObjCGCWeak() && !IvarType.isObjCGCWeak() &&
getLangOpts().getGC() != LangOptions::NonGC)) { getLangOpts().getGC() != LangOptions::NonGC)) {
Diag(PropertyDiagLoc, diag::error_weak_property) Diag(PropertyDiagLoc, diag::err_weak_property)
<< property->getDeclName() << Ivar->getDeclName(); << property->getDeclName() << Ivar->getDeclName();
Diag(Ivar->getLocation(), diag::note_ivar_decl); Diag(Ivar->getLocation(), diag::note_ivar_decl);
// Fall thru - see previous comment // Fall thru - see previous comment
} }
// Fall thru - see previous comment // Fall thru - see previous comment
if ((property->getType()->isObjCObjectPointerType() || if ((property->getType()->isObjCObjectPointerType() ||
PropType.isObjCGCStrong()) && IvarType.isObjCGCWeak() && PropType.isObjCGCStrong()) && IvarType.isObjCGCWeak() &&
getLangOpts().getGC() != LangOptions::NonGC) { getLangOpts().getGC() != LangOptions::NonGC) {
Diag(PropertyDiagLoc, diag::error_strong_property) Diag(PropertyDiagLoc, diag::err_strong_property)
<< property->getDeclName() << Ivar->getDeclName(); << property->getDeclName() << Ivar->getDeclName();
// Fall thru - see previous comment // Fall thru - see previous comment
} }
} }
if (getLangOpts().ObjCAutoRefCount || isARCWeak || if (getLangOpts().ObjCAutoRefCount || isARCWeak ||
Ivar->getType().getObjCLifetime()) Ivar->getType().getObjCLifetime())
checkARCPropertyImpl(*this, PropertyLoc, property, Ivar); checkARCPropertyImpl(*this, PropertyLoc, property, Ivar);
} else if (PropertyIvar) } else if (PropertyIvar)
// @dynamic // @dynamic
Diag(PropertyDiagLoc, diag::error_dynamic_property_ivar_decl); Diag(PropertyDiagLoc, diag::err_dynamic_property_ivar_decl);
assert (property && "ActOnPropertyImplDecl - property declaration missing"); assert (property && "ActOnPropertyImplDecl - property declaration missing");
ObjCPropertyImplDecl *PIDecl = ObjCPropertyImplDecl *PIDecl =
ObjCPropertyImplDecl::Create(Context, CurContext, AtLoc, PropertyLoc, ObjCPropertyImplDecl::Create(Context, CurContext, AtLoc, PropertyLoc,
property, property,
(Synthesize ? (Synthesize ?
ObjCPropertyImplDecl::Synthesize ObjCPropertyImplDecl::Synthesize
: ObjCPropertyImplDecl::Dynamic), : ObjCPropertyImplDecl::Dynamic),
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr &&
PIDecl->setSetterCXXAssignment(Res.getAs<Expr>()); PIDecl->setSetterCXXAssignment(Res.getAs<Expr>());
} }
} }
if (IC) { if (IC) {
if (Synthesize) if (Synthesize)
if (ObjCPropertyImplDecl *PPIDecl = if (ObjCPropertyImplDecl *PPIDecl =
IC->FindPropertyImplIvarDecl(PropertyIvar)) { IC->FindPropertyImplIvarDecl(PropertyIvar)) {
Diag(PropertyLoc, diag::error_duplicate_ivar_use) Diag(PropertyLoc, diag::err_duplicate_ivar_use)
<< PropertyId << PPIDecl->getPropertyDecl()->getIdentifier() << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
<< PropertyIvar; << PropertyIvar;
Diag(PPIDecl->getLocation(), diag::note_previous_use); Diag(PPIDecl->getLocation(), diag::note_previous_use);
} }
if (ObjCPropertyImplDecl *PPIDecl if (ObjCPropertyImplDecl *PPIDecl
= IC->FindPropertyImplDecl(PropertyId, QueryKind)) { = IC->FindPropertyImplDecl(PropertyId, QueryKind)) {
Diag(PropertyLoc, diag::error_property_implemented) << PropertyId; Diag(PropertyLoc, diag::err_property_implemented) << PropertyId;
Diag(PPIDecl->getLocation(), diag::note_previous_declaration); Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
return nullptr; return nullptr;
} }
IC->addPropertyImplementation(PIDecl); IC->addPropertyImplementation(PIDecl);
if (getLangOpts().ObjCDefaultSynthProperties && if (getLangOpts().ObjCDefaultSynthProperties &&
getLangOpts().ObjCRuntime.isNonFragile() && getLangOpts().ObjCRuntime.isNonFragile() &&
!IDecl->isObjCRequiresPropertyDefs()) { !IDecl->isObjCRequiresPropertyDefs()) {
// Diagnose if an ivar was lazily synthesdized due to a previous // Diagnose if an ivar was lazily synthesdized due to a previous
Show All 14 Lines if (getLangOpts().ObjCDefaultSynthProperties &&
<< PropertyId; << PropertyId;
Ivar->setInvalidDecl(); Ivar->setInvalidDecl();
} }
} }
} else { } else {
if (Synthesize) if (Synthesize)
if (ObjCPropertyImplDecl *PPIDecl = if (ObjCPropertyImplDecl *PPIDecl =
CatImplClass->FindPropertyImplIvarDecl(PropertyIvar)) { CatImplClass->FindPropertyImplIvarDecl(PropertyIvar)) {
Diag(PropertyDiagLoc, diag::error_duplicate_ivar_use) Diag(PropertyDiagLoc, diag::err_duplicate_ivar_use)
<< PropertyId << PPIDecl->getPropertyDecl()->getIdentifier() << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
<< PropertyIvar; << PropertyIvar;
Diag(PPIDecl->getLocation(), diag::note_previous_use); Diag(PPIDecl->getLocation(), diag::note_previous_use);
} }
if (ObjCPropertyImplDecl *PPIDecl = if (ObjCPropertyImplDecl *PPIDecl =
CatImplClass->FindPropertyImplDecl(PropertyId, QueryKind)) { CatImplClass->FindPropertyImplDecl(PropertyId, QueryKind)) {
Diag(PropertyDiagLoc, diag::error_property_implemented) << PropertyId; Diag(PropertyDiagLoc, diag::err_property_implemented) << PropertyId;
Diag(PPIDecl->getLocation(), diag::note_previous_declaration); Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
return nullptr; return nullptr;
} }
CatImplClass->addPropertyImplementation(PIDecl); CatImplClass->addPropertyImplementation(PIDecl);
} }
return PIDecl; return PIDecl;
} }
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines if (!compat) {
const ObjCObjectPointerType *propertyObjCPtr = nullptr; const ObjCObjectPointerType *propertyObjCPtr = nullptr;
const ObjCObjectPointerType *getterObjCPtr = nullptr; const ObjCObjectPointerType *getterObjCPtr = nullptr;
if ((propertyObjCPtr = if ((propertyObjCPtr =
PropertyRValueType->getAs<ObjCObjectPointerType>()) && PropertyRValueType->getAs<ObjCObjectPointerType>()) &&
(getterObjCPtr = GetterType->getAs<ObjCObjectPointerType>())) (getterObjCPtr = GetterType->getAs<ObjCObjectPointerType>()))
compat = Context.canAssignObjCInterfaces(getterObjCPtr, propertyObjCPtr); compat = Context.canAssignObjCInterfaces(getterObjCPtr, propertyObjCPtr);
else if (CheckAssignmentConstraints(Loc, GetterType, PropertyRValueType) else if (CheckAssignmentConstraints(Loc, GetterType, PropertyRValueType)
!= Compatible) { != Compatible) {
Diag(Loc, diag::error_property_accessor_type) Diag(Loc, diag::err_property_accessor_type)
<< property->getDeclName() << PropertyRValueType << property->getDeclName() << PropertyRValueType
<< GetterMethod->getSelector() << GetterType; << GetterMethod->getSelector() << GetterType;
Diag(GetterMethod->getLocation(), diag::note_declared_at); Diag(GetterMethod->getLocation(), diag::note_declared_at);
return true; return true;
} else { } else {
compat = true; compat = true;
QualType lhsType = Context.getCanonicalType(PropertyRValueType); QualType lhsType = Context.getCanonicalType(PropertyRValueType);
QualType rhsType =Context.getCanonicalType(GetterType).getUnqualifiedType(); QualType rhsType =Context.getCanonicalType(GetterType).getUnqualifiedType();
▲ Show 20 Lines • Show All 1,019 Lines • Show Last 20 Lines

lib/Sema/SemaOverload.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 811 Lines • ▼ Show 20 Lines for (unsigned ii = 0, ie = i->NumConversions; ii != ie; ++ii)
i->Conversions[ii].~ImplicitConversionSequence(); i->Conversions[ii].~ImplicitConversionSequence();
if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction) if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
i->DeductionFailure.Destroy(); i->DeductionFailure.Destroy();
} }
} }
void OverloadCandidateSet::clear() { void OverloadCandidateSet::clear() {
destroyCandidates(); destroyCandidates();
ConversionSequenceAllocator.Reset();
NumInlineSequences = 0; NumInlineSequences = 0;
Candidates.clear(); Candidates.clear();
Functions.clear(); Functions.clear();
} }
namespace { namespace {
class UnbridgedCastsSet { class UnbridgedCastsSet {
struct Entry { struct Entry {
▲ Show 20 Lines • Show All 12,465 Lines • Show Last 20 Lines

lib/Sema/SemaPseudoObject.cpp

Show First 20 Lines • Show All 655 Lines • ▼ Show 20 Lines if (setter->isPropertyAccessor() && warn)
char front = thisPropertyName.front(); char front = thisPropertyName.front();
front = isLowercase(front) ? toUppercase(front) : toLowercase(front); front = isLowercase(front) ? toUppercase(front) : toLowercase(front);
SmallString<100> PropertyName = thisPropertyName; SmallString<100> PropertyName = thisPropertyName;
PropertyName[0] = front; PropertyName[0] = front;
IdentifierInfo *AltMember = &S.PP.getIdentifierTable().get(PropertyName); IdentifierInfo *AltMember = &S.PP.getIdentifierTable().get(PropertyName);
if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration( if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(
AltMember, prop->getQueryKind())) AltMember, prop->getQueryKind()))
if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) { if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {
S.Diag(RefExpr->getExprLoc(), diag::error_property_setter_ambiguous_use) S.Diag(RefExpr->getExprLoc(), diag::err_property_setter_ambiguous_use)
<< prop << prop1 << setter->getSelector(); << prop << prop1 << setter->getSelector();
S.Diag(prop->getLocation(), diag::note_property_declare); S.Diag(prop->getLocation(), diag::note_property_declare);
S.Diag(prop1->getLocation(), diag::note_property_declare); S.Diag(prop1->getLocation(), diag::note_property_declare);
} }
} }
Setter = setter; Setter = setter;
return true; return true;
} }
▲ Show 20 Lines • Show All 426 Lines • ▼ Show 20 Lines if (NoIntegrals == 0 && NoObjCIdPointers == 0) {
// No conversion function was found. Issue diagnostic and return. // No conversion function was found. Issue diagnostic and return.
Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion) Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
<< FromE->getType(); << FromE->getType();
return OS_Error; return OS_Error;
} }
Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion) Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion)
<< FromE->getType(); << FromE->getType();
for (unsigned int i = 0; i < ConversionDecls.size(); i++) for (unsigned int i = 0; i < ConversionDecls.size(); i++)
Diag(ConversionDecls[i]->getLocation(), diag::not_conv_function_declared_at); Diag(ConversionDecls[i]->getLocation(),
diag::note_conv_function_declared_at);
return OS_Error; return OS_Error;
} }
/// CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF /// CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF
/// objects used as dictionary subscript key objects. /// objects used as dictionary subscript key objects.
static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT, static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT,
Expr *Key) { Expr *Key) {
if (ContainerT.isNull()) if (ContainerT.isNull())
▲ Show 20 Lines • Show All 358 Lines • ▼ Show 20 LinesExprResult MSPropertyOpBuilder::buildGet() {
CXXScopeSpec SS; CXXScopeSpec SS;
SS.Adopt(RefExpr->getQualifierLoc()); SS.Adopt(RefExpr->getQualifierLoc());
ExprResult GetterExpr = ExprResult GetterExpr =
S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(), S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
RefExpr->isArrow() ? tok::arrow : tok::period, SS, RefExpr->isArrow() ? tok::arrow : tok::period, SS,
SourceLocation(), GetterName, nullptr); SourceLocation(), GetterName, nullptr);
if (GetterExpr.isInvalid()) { if (GetterExpr.isInvalid()) {
S.Diag(RefExpr->getMemberLoc(), S.Diag(RefExpr->getMemberLoc(),
diag::error_cannot_find_suitable_accessor) << 0 /* getter */ diag::err_cannot_find_suitable_accessor) << 0 /* getter */
<< RefExpr->getPropertyDecl(); << RefExpr->getPropertyDecl();
return ExprError(); return ExprError();
} }
return S.ActOnCallExpr(S.getCurScope(), GetterExpr.get(), return S.ActOnCallExpr(S.getCurScope(), GetterExpr.get(),
RefExpr->getSourceRange().getBegin(), CallArgs, RefExpr->getSourceRange().getBegin(), CallArgs,
RefExpr->getSourceRange().getEnd()); RefExpr->getSourceRange().getEnd());
} }
Show All 12 LinesExprResult MSPropertyOpBuilder::buildSet(Expr *op, SourceLocation sl,
CXXScopeSpec SS; CXXScopeSpec SS;
SS.Adopt(RefExpr->getQualifierLoc()); SS.Adopt(RefExpr->getQualifierLoc());
ExprResult SetterExpr = ExprResult SetterExpr =
S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(), S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
RefExpr->isArrow() ? tok::arrow : tok::period, SS, RefExpr->isArrow() ? tok::arrow : tok::period, SS,
SourceLocation(), SetterName, nullptr); SourceLocation(), SetterName, nullptr);
if (SetterExpr.isInvalid()) { if (SetterExpr.isInvalid()) {
S.Diag(RefExpr->getMemberLoc(), S.Diag(RefExpr->getMemberLoc(),
diag::error_cannot_find_suitable_accessor) << 1 /* setter */ diag::err_cannot_find_suitable_accessor) << 1 /* setter */
<< RefExpr->getPropertyDecl(); << RefExpr->getPropertyDecl();
return ExprError(); return ExprError();
} }
SmallVector<Expr*, 4> ArgExprs; SmallVector<Expr*, 4> ArgExprs;
ArgExprs.append(CallArgs.begin(), CallArgs.end()); ArgExprs.append(CallArgs.begin(), CallArgs.end());
ArgExprs.push_back(op); ArgExprs.push_back(op);
return S.ActOnCallExpr(S.getCurScope(), SetterExpr.get(), return S.ActOnCallExpr(S.getCurScope(), SetterExpr.get(),
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

lib/Sema/SemaStmt.cpp

Show First 20 Lines • Show All 3,445 Lines • ▼ Show 20 Lines if (Throw) {
Throw = Result.get(); Throw = Result.get();
QualType ThrowType = Throw->getType(); QualType ThrowType = Throw->getType();
// Make sure the expression type is an ObjC pointer or "void *". // Make sure the expression type is an ObjC pointer or "void *".
if (!ThrowType->isDependentType() && if (!ThrowType->isDependentType() &&
!ThrowType->isObjCObjectPointerType()) { !ThrowType->isObjCObjectPointerType()) {
const PointerType *PT = ThrowType->getAs<PointerType>(); const PointerType *PT = ThrowType->getAs<PointerType>();
if (!PT || !PT->getPointeeType()->isVoidType()) if (!PT || !PT->getPointeeType()->isVoidType())
return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object) return StmtError(Diag(AtLoc, diag::err_objc_throw_expects_object)
<< Throw->getType() << Throw->getSourceRange()); << Throw->getType() << Throw->getSourceRange());
} }
} }
return new (Context) ObjCAtThrowStmt(AtLoc, Throw); return new (Context) ObjCAtThrowStmt(AtLoc, Throw);
} }
StmtResult StmtResult
Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw, Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
Scope *CurScope) { Scope *CurScope) {
if (!getLangOpts().ObjCExceptions) if (!getLangOpts().ObjCExceptions)
Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw"; Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw";
if (!Throw) { if (!Throw) {
// @throw without an expression designates a rethrow (which must occur // @throw without an expression designates a rethrow (which must occur
// in the context of an @catch clause). // in the context of an @catch clause).
Scope *AtCatchParent = CurScope; Scope *AtCatchParent = CurScope;
while (AtCatchParent && !AtCatchParent->isAtCatchScope()) while (AtCatchParent && !AtCatchParent->isAtCatchScope())
AtCatchParent = AtCatchParent->getParent(); AtCatchParent = AtCatchParent->getParent();
if (!AtCatchParent) if (!AtCatchParent)
return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch)); return StmtError(Diag(AtLoc, diag::err_rethrow_used_outside_catch));
} }
return BuildObjCAtThrowStmt(AtLoc, Throw); return BuildObjCAtThrowStmt(AtLoc, Throw);
} }
ExprResult ExprResult
Sema::ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand) { Sema::ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand) {
ExprResult result = DefaultLvalueConversion(operand); ExprResult result = DefaultLvalueConversion(operand);
if (result.isInvalid()) if (result.isInvalid())
return ExprError(); return ExprError();
operand = result.get(); operand = result.get();
// Make sure the expression type is an ObjC pointer or "void *". // Make sure the expression type is an ObjC pointer or "void *".
QualType type = operand->getType(); QualType type = operand->getType();
if (!type->isDependentType() && if (!type->isDependentType() &&
!type->isObjCObjectPointerType()) { !type->isObjCObjectPointerType()) {
const PointerType *pointerType = type->getAs<PointerType>(); const PointerType *pointerType = type->getAs<PointerType>();
if (!pointerType || !pointerType->getPointeeType()->isVoidType()) { if (!pointerType || !pointerType->getPointeeType()->isVoidType()) {
if (getLangOpts().CPlusPlus) { if (getLangOpts().CPlusPlus) {
if (RequireCompleteType(atLoc, type, if (RequireCompleteType(atLoc, type,
diag::err_incomplete_receiver_type)) diag::err_incomplete_receiver_type))
return Diag(atLoc, diag::error_objc_synchronized_expects_object) return Diag(atLoc, diag::err_objc_synchronized_expects_object)
<< type << operand->getSourceRange(); << type << operand->getSourceRange();
ExprResult result = PerformContextuallyConvertToObjCPointer(operand); ExprResult result = PerformContextuallyConvertToObjCPointer(operand);
if (result.isInvalid()) if (result.isInvalid())
return ExprError(); return ExprError();
if (!result.isUsable()) if (!result.isUsable())
return Diag(atLoc, diag::error_objc_synchronized_expects_object) return Diag(atLoc, diag::err_objc_synchronized_expects_object)
<< type << operand->getSourceRange(); << type << operand->getSourceRange();
operand = result.get(); operand = result.get();
} else { } else {
return Diag(atLoc, diag::error_objc_synchronized_expects_object) return Diag(atLoc, diag::err_objc_synchronized_expects_object)
<< type << operand->getSourceRange(); << type << operand->getSourceRange();
} }
} }
} }
// The operand to @synchronized is a full-expression. // The operand to @synchronized is a full-expression.
return ActOnFinishFullExpr(operand); return ActOnFinishFullExpr(operand);
} }
▲ Show 20 Lines • Show All 496 Lines • Show Last 20 Lines

lib/Sema/SemaTemplate.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 7,429 Lines • ▼ Show 20 Lines for (NestedNameSpecifier *NNS = SS.getScopeRep(); NNS;
NNS = NNS->getPrefix()) NNS = NNS->getPrefix())
if (const Type *T = NNS->getAsType()) if (const Type *T = NNS->getAsType())
if (isa<TemplateSpecializationType>(T)) if (isa<TemplateSpecializationType>(T))
return true; return true;
return false; return false;
} }
/// Make a dllexport or dllimport attr on a class template specialization take
/// effect.
static void dllExportImportClassTemplateSpecialization(
Sema &S, ClassTemplateSpecializationDecl *Def) {
auto *A = cast_or_null<InheritableAttr>(getDLLAttr(Def));
assert(A && "dllExportImportClassTemplateSpecialization called "
"on Def without dllexport or dllimport");
// We reject explicit instantiations in class scope, so there should
// never be any delayed exported classes to worry about.
assert(S.DelayedDllExportClasses.empty() &&
"delayed exports present at explicit instantiation");
S.checkClassLevelDLLAttribute(Def);
// Propagate attribute to base class templates.
for (auto &B : Def->bases()) {
if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
B.getType()->getAsCXXRecordDecl()))
S.propagateDLLAttrToBaseClassTemplate(Def, A, BT, B.getLocStart());
}
S.referenceDLLExportedClassMethods();
}
// Explicit instantiation of a class template specialization // Explicit instantiation of a class template specialization
DeclResult DeclResult
Sema::ActOnExplicitInstantiation(Scope *S, Sema::ActOnExplicitInstantiation(Scope *S,
SourceLocation ExternLoc, SourceLocation ExternLoc,
SourceLocation TemplateLoc, SourceLocation TemplateLoc,
unsigned TagSpec, unsigned TagSpec,
SourceLocation KWLoc, SourceLocation KWLoc,
const CXXScopeSpec &SS, const CXXScopeSpec &SS,
▲ Show 20 Lines • Show All 230 Lines • ▼ Show 20 Lines if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) { Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
// In the MS ABI, an explicit instantiation definition can add a dll // In the MS ABI, an explicit instantiation definition can add a dll
// attribute to a template with a previous instantiation declaration. // attribute to a template with a previous instantiation declaration.
// MinGW doesn't allow this. // MinGW doesn't allow this.
auto *A = cast<InheritableAttr>( auto *A = cast<InheritableAttr>(
getDLLAttr(Specialization)->clone(getASTContext())); getDLLAttr(Specialization)->clone(getASTContext()));
A->setInherited(true); A->setInherited(true);
Def->addAttr(A); Def->addAttr(A);
dllExportImportClassTemplateSpecialization(*this, Def);
// We reject explicit instantiations in class scope, so there should
// never be any delayed exported classes to worry about.
assert(DelayedDllExportClasses.empty() &&
"delayed exports present at explicit instantiation");
checkClassLevelDLLAttribute(Def);
referenceDLLExportedClassMethods();
// Propagate attribute to base class templates.
for (auto &B : Def->bases()) {
if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
B.getType()->getAsCXXRecordDecl()))
propagateDLLAttrToBaseClassTemplate(Def, A, BT, B.getLocStart());
} }
} }
// Fix a TSK_ImplicitInstantiation followed by a
// TSK_ExplicitInstantiationDefinition
if (Old_TSK == TSK_ImplicitInstantiation &&
Specialization->hasAttr<DLLExportAttr>() &&
(Context.getTargetInfo().getCXXABI().isMicrosoft() ||
Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
// In the MS ABI, an explicit instantiation definition can add a dll
// attribute to a template with a previous implicit instantiation.
// MinGW doesn't allow this. We limit clang to only adding dllexport, to
// avoid potentially strange codegen behavior. For example, if we extend
// this conditional to dllimport, and we have a source file calling a
// method on an implicitly instantiated template class instance and then
// declaring a dllimport explicit instantiation definition for the same
// template class, the codegen for the method call will not respect the
// dllimport, while it will with cl. The Def will already have the DLL
// attribute, since the Def and Specialization will be the same in the
// case of Old_TSK == TSK_ImplicitInstantiation, and we already added the
// attribute to the Specialization; we just need to make it take effect.
assert(Def == Specialization &&
"Def and Specialization should match for implicit instantiation");
dllExportImportClassTemplateSpecialization(*this, Def);
} }
// Set the template specialization kind. Make sure it is set before // Set the template specialization kind. Make sure it is set before
// instantiating the members which will trigger ASTConsumer callbacks. // instantiating the members which will trigger ASTConsumer callbacks.
Specialization->setTemplateSpecializationKind(TSK); Specialization->setTemplateSpecializationKind(TSK);
InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK); InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
} else { } else {
▲ Show 20 Lines • Show All 1,167 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

Show First 20 Lines • Show All 721 Lines • ▼ Show 20 Linesvoid DynamicTypePropagation::checkPreObjCMessage(const ObjCMethodCall &M,
const ObjCMessageExpr *MessageExpr = M.getOriginExpr(); const ObjCMessageExpr *MessageExpr = M.getOriginExpr();
const ObjCMethodDecl *Method = const ObjCMethodDecl *Method =
findMethodDecl(MessageExpr, *TrackedType, ASTCtxt); findMethodDecl(MessageExpr, *TrackedType, ASTCtxt);
// It is possible to call non-existent methods in Obj-C. // It is possible to call non-existent methods in Obj-C.
if (!Method) if (!Method)
return; return;
// If the method is declared on a class that has a non-invariant
// type parameter, don't warn about parameter mismatches after performing
// substitution. This prevents warning when the programmer has purposely
// casted the receiver to a super type or unspecialized type but the analyzer
// has a more precise tracked type than the programmer intends at the call
// site.
//
// For example, consider NSArray (which has a covariant type parameter)
// and NSMutableArray (a subclass of NSArray where the type parameter is
// invariant):
// NSMutableArray *a = [[NSMutableArray<NSString *> alloc] init;
//
// [a containsObject:number]; // Safe: -containsObject is defined on NSArray.
// NSArray<NSObject *> *other = [a arrayByAddingObject:number] // Safe
//
// [a addObject:number] // Unsafe: -addObject: is defined on NSMutableArray
//
const ObjCInterfaceDecl *Interface = Method->getClassInterface();
if (!Interface)
return;
ObjCTypeParamList *TypeParams = Interface->getTypeParamList();
if (!TypeParams)
return;
for (ObjCTypeParamDecl *TypeParam : *TypeParams) {
if (TypeParam->getVariance() != ObjCTypeParamVariance::Invariant)
return;
}
Optional<ArrayRef<QualType>> TypeArgs = Optional<ArrayRef<QualType>> TypeArgs =
(*TrackedType)->getObjCSubstitutions(Method->getDeclContext()); (*TrackedType)->getObjCSubstitutions(Method->getDeclContext());
// This case might happen when there is an unspecialized override of a // This case might happen when there is an unspecialized override of a
// specialized method. // specialized method.
if (!TypeArgs) if (!TypeArgs)
return; return;
for (unsigned i = 0; i < Method->param_size(); i++) { for (unsigned i = 0; i < Method->param_size(); i++) {
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Core/ExprEngineC.cpp

Show First 20 Lines • Show All 474 Lines • ▼ Show 20 Linesvoid ExprEngine::VisitCompoundLiteralExpr(const CompoundLiteralExpr *CL,
if (isa<CXXConstructExpr>(Init)) { if (isa<CXXConstructExpr>(Init)) {
// No work needed. Just pass the value up to this expression. // No work needed. Just pass the value up to this expression.
} else { } else {
assert(isa<InitListExpr>(Init)); assert(isa<InitListExpr>(Init));
Loc CLLoc = State->getLValue(CL, LCtx); Loc CLLoc = State->getLValue(CL, LCtx);
State = State->bindLoc(CLLoc, V); State = State->bindLoc(CLLoc, V);
// Compound literal expressions are a GNU extension in C++. if (CL->isGLValue())
// Unlike in C, where CLs are lvalues, in C++ CLs are prvalues,
// and like temporary objects created by the functional notation T()
// CLs are destroyed at the end of the containing full-expression.
// HOWEVER, an rvalue of array type is not something the analyzer can
// reason about, since we expect all regions to be wrapped in Locs.
// So we treat array CLs as lvalues as well, knowing that they will decay
// to pointers as soon as they are used.
if (CL->isGLValue() || CL->getType()->isArrayType())
V = CLLoc; V = CLLoc;
} }
B.generateNode(CL, Pred, State->BindExpr(CL, LCtx, V)); B.generateNode(CL, Pred, State->BindExpr(CL, LCtx, V));
} }
void ExprEngine::VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred, void ExprEngine::VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred,
ExplodedNodeSet &Dst) { ExplodedNodeSet &Dst) {
▲ Show 20 Lines • Show All 535 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Core/SymbolManager.cpp

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
void SymbolMetadata::dumpToStream(raw_ostream &os) const { void SymbolMetadata::dumpToStream(raw_ostream &os) const {
os << "meta_$" << getSymbolID() << '{' os << "meta_$" << getSymbolID() << '{'
<< getRegion() << ',' << T.getAsString() << '}'; << getRegion() << ',' << T.getAsString() << '}';
} }
void SymbolData::anchor() { } void SymbolData::anchor() { }
void SymbolRegionValue::dumpToStream(raw_ostream &os) const { void SymbolRegionValue::dumpToStream(raw_ostream &os) const {
os << "reg_$" << getSymbolID() << "<" << R << ">"; os << "reg_$" << getSymbolID()
<< '<' << getType().getAsString() << ' ' << R << '>';
NoQUnsubmitted
Not Done
ReplyInline Actions

The rest of the code uses single-quotes for single characters, even though it's not really important here.

NoQ: The rest of the code uses single-quotes for single characters, even though it's not really…
} }
bool SymExpr::symbol_iterator::operator==(const symbol_iterator &X) const { bool SymExpr::symbol_iterator::operator==(const symbol_iterator &X) const {
return itr == X.itr; return itr == X.itr;
} }
bool SymExpr::symbol_iterator::operator!=(const symbol_iterator &X) const { bool SymExpr::symbol_iterator::operator!=(const symbol_iterator &X) const {
return itr != X.itr; return itr != X.itr;
▲ Show 20 Lines • Show All 465 Lines • Show Last 20 Lines

lib/Tooling/CompilationDatabase.cpp

Show First 20 Lines • Show All 294 Lines • ▼ Show 20 Lines
} }
FixedCompilationDatabase:: FixedCompilationDatabase::
FixedCompilationDatabase(Twine Directory, ArrayRef<std::string> CommandLine) { FixedCompilationDatabase(Twine Directory, ArrayRef<std::string> CommandLine) {
std::vector<std::string> ToolCommandLine(1, "clang-tool"); std::vector<std::string> ToolCommandLine(1, "clang-tool");
ToolCommandLine.insert(ToolCommandLine.end(), ToolCommandLine.insert(ToolCommandLine.end(),
CommandLine.begin(), CommandLine.end()); CommandLine.begin(), CommandLine.end());
CompileCommands.emplace_back(Directory, StringRef(), CompileCommands.emplace_back(Directory, StringRef(),
std::move(ToolCommandLine)); std::move(ToolCommandLine),
StringRef());
} }
std::vector<CompileCommand> std::vector<CompileCommand>
FixedCompilationDatabase::getCompileCommands(StringRef FilePath) const { FixedCompilationDatabase::getCompileCommands(StringRef FilePath) const {
std::vector<CompileCommand> Result(CompileCommands); std::vector<CompileCommand> Result(CompileCommands);
Result[0].CommandLine.push_back(FilePath); Result[0].CommandLine.push_back(FilePath);
Result[0].Filename = FilePath; Result[0].Filename = FilePath;
return Result; return Result;
Show All 22 Lines

lib/Tooling/JSONCompilationDatabase.cpp

Show First 20 Lines • Show All 251 Lines • ▼ Show 20 Lines
} }
void JSONCompilationDatabase::getCommands( void JSONCompilationDatabase::getCommands(
ArrayRef<CompileCommandRef> CommandsRef, ArrayRef<CompileCommandRef> CommandsRef,
std::vector<CompileCommand> &Commands) const { std::vector<CompileCommand> &Commands) const {
for (int I = 0, E = CommandsRef.size(); I != E; ++I) { for (int I = 0, E = CommandsRef.size(); I != E; ++I) {
SmallString<8> DirectoryStorage; SmallString<8> DirectoryStorage;
SmallString<32> FilenameStorage; SmallString<32> FilenameStorage;
SmallString<32> OutputStorage;
auto Output = std::get<3>(CommandsRef[I]);
Commands.emplace_back( Commands.emplace_back(
std::get<0>(CommandsRef[I])->getValue(DirectoryStorage), std::get<0>(CommandsRef[I])->getValue(DirectoryStorage),
std::get<1>(CommandsRef[I])->getValue(FilenameStorage), std::get<1>(CommandsRef[I])->getValue(FilenameStorage),
nodeToCommandLine(Syntax, std::get<2>(CommandsRef[I]))); nodeToCommandLine(Syntax, std::get<2>(CommandsRef[I])),
Output ? Output->getValue(OutputStorage) : "");
} }
} }
bool JSONCompilationDatabase::parse(std::string &ErrorMessage) { bool JSONCompilationDatabase::parse(std::string &ErrorMessage) {
llvm::yaml::document_iterator I = YAMLStream.begin(); llvm::yaml::document_iterator I = YAMLStream.begin();
if (I == YAMLStream.end()) { if (I == YAMLStream.end()) {
ErrorMessage = "Error while parsing YAML."; ErrorMessage = "Error while parsing YAML.";
return false; return false;
Show All 12 Lines for (auto& NextObject : *Array) {
llvm::yaml::MappingNode *Object = dyn_cast<llvm::yaml::MappingNode>(&NextObject); llvm::yaml::MappingNode *Object = dyn_cast<llvm::yaml::MappingNode>(&NextObject);
if (!Object) { if (!Object) {
ErrorMessage = "Expected object."; ErrorMessage = "Expected object.";
return false; return false;
} }
llvm::yaml::ScalarNode *Directory = nullptr; llvm::yaml::ScalarNode *Directory = nullptr;
llvm::Optional<std::vector<llvm::yaml::ScalarNode *>> Command; llvm::Optional<std::vector<llvm::yaml::ScalarNode *>> Command;
llvm::yaml::ScalarNode *File = nullptr; llvm::yaml::ScalarNode *File = nullptr;
llvm::yaml::ScalarNode *Output = nullptr;
for (auto& NextKeyValue : *Object) { for (auto& NextKeyValue : *Object) {
llvm::yaml::ScalarNode *KeyString = llvm::yaml::ScalarNode *KeyString =
dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey()); dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
if (!KeyString) { if (!KeyString) {
ErrorMessage = "Expected strings as key."; ErrorMessage = "Expected strings as key.";
return false; return false;
} }
SmallString<10> KeyStorage; SmallString<10> KeyStorage;
Show All 26 Lines for (auto& NextKeyValue : *Object) {
} }
Command->push_back(Scalar); Command->push_back(Scalar);
} }
} else if (KeyValue == "command") { } else if (KeyValue == "command") {
if (!Command) if (!Command)
Command = std::vector<llvm::yaml::ScalarNode *>(1, ValueString); Command = std::vector<llvm::yaml::ScalarNode *>(1, ValueString);
} else if (KeyValue == "file") { } else if (KeyValue == "file") {
File = ValueString; File = ValueString;
} else if (KeyValue == "output") {
Output = ValueString;
} else { } else {
ErrorMessage = ("Unknown key: \"" + ErrorMessage = ("Unknown key: \"" +
KeyString->getRawValue() + "\"").str(); KeyString->getRawValue() + "\"").str();
return false; return false;
} }
} }
if (!File) { if (!File) {
ErrorMessage = "Missing key: \"file\"."; ErrorMessage = "Missing key: \"file\".";
Show All 14 Lines if (llvm::sys::path::is_relative(FileName)) {
SmallString<8> DirectoryStorage; SmallString<8> DirectoryStorage;
SmallString<128> AbsolutePath( SmallString<128> AbsolutePath(
Directory->getValue(DirectoryStorage)); Directory->getValue(DirectoryStorage));
llvm::sys::path::append(AbsolutePath, FileName); llvm::sys::path::append(AbsolutePath, FileName);
llvm::sys::path::native(AbsolutePath, NativeFilePath); llvm::sys::path::native(AbsolutePath, NativeFilePath);
} else { } else {
llvm::sys::path::native(FileName, NativeFilePath); llvm::sys::path::native(FileName, NativeFilePath);
} }
auto Cmd = CompileCommandRef(Directory, File, *Command); auto Cmd = CompileCommandRef(Directory, File, *Command, Output);
IndexByFile[NativeFilePath].push_back(Cmd); IndexByFile[NativeFilePath].push_back(Cmd);
AllCommands.push_back(Cmd); AllCommands.push_back(Cmd);
MatchTrie.insert(NativeFilePath); MatchTrie.insert(NativeFilePath);
} }
return true; return true;
} }
} // end namespace tooling } // end namespace tooling
} // end namespace clang } // end namespace clang

test/Analysis/explain-svals.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Linesvoid test_4(int x, int y) {
clang_analyzer_explain(1 + y); // expected-warning-re{{{{^\(argument 'y'\) \+ 1$}}}} clang_analyzer_explain(1 + y); // expected-warning-re{{{{^\(argument 'y'\) \+ 1$}}}}
clang_analyzer_explain(x + y); // expected-warning-re{{{{^unknown value$}}}} clang_analyzer_explain(x + y); // expected-warning-re{{{{^unknown value$}}}}
clang_analyzer_explain(z); // expected-warning-re{{{{^undefined value$}}}} clang_analyzer_explain(z); // expected-warning-re{{{{^undefined value$}}}}
clang_analyzer_explain(&z); // expected-warning-re{{{{^pointer to local variable 'z'$}}}} clang_analyzer_explain(&z); // expected-warning-re{{{{^pointer to local variable 'z'$}}}}
clang_analyzer_explain(stat); // expected-warning-re{{{{^signed 32-bit integer '0'$}}}} clang_analyzer_explain(stat); // expected-warning-re{{{{^signed 32-bit integer '0'$}}}}
clang_analyzer_explain(&stat); // expected-warning-re{{{{^pointer to static local variable 'stat'$}}}} clang_analyzer_explain(&stat); // expected-warning-re{{{{^pointer to static local variable 'stat'$}}}}
clang_analyzer_explain(stat_glob); // expected-warning-re{{{{^initial value of global variable 'stat_glob'$}}}} clang_analyzer_explain(stat_glob); // expected-warning-re{{{{^initial value of global variable 'stat_glob'$}}}}
clang_analyzer_explain(&stat_glob); // expected-warning-re{{{{^pointer to global variable 'stat_glob'$}}}} clang_analyzer_explain(&stat_glob); // expected-warning-re{{{{^pointer to global variable 'stat_glob'$}}}}
clang_analyzer_explain((int[]){1, 2, 3}); // expected-warning-re{{{{^pointer to element of type 'int' with index 0 of compound literal \(int \[3\]\)\{1, 2, 3\}$}}}} clang_analyzer_explain((int[]){1, 2, 3}); // expected-warning-re{{{{^pointer to element of type 'int' with index 0 of temporary object constructed at statement '\(int \[3\]\)\{1, 2, 3\}'$}}}}
} }
namespace { namespace {
class C { class C {
int x[10]; int x[10];
public: public:
void test_5(int i) { void test_5(int i) {
Show All 11 Lines

test/Analysis/expr-inspection.c

// RUN: %clang_cc1 -analyze -analyzer-checker=debug.ExprInspection -verify %s 2>&1 | FileCheck %s // RUN: %clang_cc1 -analyze -analyzer-checker=debug.ExprInspection -verify %s 2>&1 | FileCheck %s
// Self-tests for the debug.ExprInspection checker. // Self-tests for the debug.ExprInspection checker.
void clang_analyzer_dump(int x); void clang_analyzer_dump(int x);
void clang_analyzer_printState(); void clang_analyzer_printState();
void clang_analyzer_numTimesReached(); void clang_analyzer_numTimesReached();
void foo(int x) { void foo(int x) {
clang_analyzer_dump(x); // expected-warning{{reg_$0<x>}} clang_analyzer_dump(x); // expected-warning{{reg_$0<int x>}}
int y = 1; int y = 1;
clang_analyzer_printState(); clang_analyzer_printState();
for (; y < 3; ++y) for (; y < 3; ++y)
clang_analyzer_numTimesReached(); // expected-warning{{2}} clang_analyzer_numTimesReached(); // expected-warning{{2}}
} }
// CHECK: Store (direct and default bindings) // CHECK: Store (direct and default bindings)
// CHECK-NEXT: (y,0,direct) : 1 S32b // CHECK-NEXT: (y,0,direct) : 1 S32b
// CHECK: Expressions: // CHECK: Expressions:
// CHECK-NEXT: clang_analyzer_printState : &code{clang_analyzer_printState} // CHECK-NEXT: clang_analyzer_printState : &code{clang_analyzer_printState}
// CHECK-NEXT: Ranges are empty. // CHECK-NEXT: Ranges are empty.

test/Analysis/generics.m

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show All 37 Lines
@interface NSSet : NSObject <NSCopying> @interface NSSet : NSObject <NSCopying>
@end @end
@interface NSArray<__covariant ObjectType> : NSObject @interface NSArray<__covariant ObjectType> : NSObject
+ (instancetype)arrayWithObjects:(const ObjectType [])objects count:(NSUInteger)count; + (instancetype)arrayWithObjects:(const ObjectType [])objects count:(NSUInteger)count;
+ (instancetype)getEmpty; + (instancetype)getEmpty;
+ (NSArray<ObjectType> *)getEmpty2; + (NSArray<ObjectType> *)getEmpty2;
- (BOOL)contains:(ObjectType)obj; - (BOOL)contains:(ObjectType)obj;
- (BOOL)containsObject:(ObjectType)anObject;
- (ObjectType)getObjAtIndex:(NSUInteger)idx; - (ObjectType)getObjAtIndex:(NSUInteger)idx;
- (ObjectType)objectAtIndexedSubscript:(NSUInteger)idx; - (ObjectType)objectAtIndexedSubscript:(NSUInteger)idx;
- (NSArray<ObjectType> *)arrayByAddingObject:(ObjectType)anObject;
@property(readonly) ObjectType firstObject; @property(readonly) ObjectType firstObject;
@end @end
@interface NSMutableArray<ObjectType> : NSArray<ObjectType>
- (void)addObject:(ObjectType)anObject;
- (instancetype)init;
@end
@interface MutableArray<ObjectType> : NSArray<ObjectType> @interface MutableArray<ObjectType> : NSArray<ObjectType>
- (void)addObject:(ObjectType)anObject; - (void)addObject:(ObjectType)anObject;
@end @end
@interface LegacyMutableArray : MutableArray @interface LegacyMutableArray : MutableArray
@end @end
@interface LegacySpecialMutableArray : LegacyMutableArray @interface LegacySpecialMutableArray : LegacyMutableArray
Show All 23 Lines
} }
void doStuff(NSArray<NSNumber *> *); void doStuff(NSArray<NSNumber *> *);
void withArrString(NSArray<NSString *> *); void withArrString(NSArray<NSString *> *);
void withArrMutableString(NSArray<NSMutableString *> *); void withArrMutableString(NSArray<NSMutableString *> *);
void withMutArrString(MutableArray<NSString *> *); void withMutArrString(MutableArray<NSString *> *);
void withMutArrMutableString(MutableArray<NSMutableString *> *); void withMutArrMutableString(MutableArray<NSMutableString *> *);
void incompatibleTypesErased(NSArray *a, NSArray<NSString *> *b, void incompatibleTypesErased(NSArray *a, NSMutableArray<NSString *> *b,
NSArray<NSNumber *> *c) { NSArray<NSNumber *> *c,
NSMutableArray *d) {
a = b; a = b;
c = a; // expected-warning {{Conversion from value of type 'NSArray<NSString *> *' to incompatible type 'NSArray<NSNumber *> *'}} c = a; // expected-warning {{Conversion from value of type 'NSMutableArray<NSString *> *' to incompatible type 'NSArray<NSNumber *> *'}}
[a contains: [[NSNumber alloc] init]]; // expected-warning {{Conversion}} [a contains: [[NSNumber alloc] init]];
[a contains: [[NSString alloc] init]]; [a contains: [[NSString alloc] init]];
doStuff(a); // expected-warning {{Conversion}} doStuff(a); // expected-warning {{Conversion}}
d = b;
[d addObject: [[NSNumber alloc] init]]; // expected-warning {{Conversion from value of type 'NSNumber *' to incompatible type 'NSString *'}}
} }
void crossProceduralErasedTypes() { void crossProceduralErasedTypes() {
NSArray<NSString *> *a = getTypedStuff(); // expected-warning {{Conversion}} NSArray<NSString *> *a = getTypedStuff(); // expected-warning {{Conversion}}
} }
void incompatibleTypesErasedReverseConversion(NSArray *a, void incompatibleTypesErasedReverseConversion(NSMutableArray *a,
NSArray<NSString *> *b) { NSMutableArray<NSString *> *b) {
b = a; b = a;
[a contains: [[NSNumber alloc] init]]; // expected-warning {{Conversion}} [a contains: [[NSNumber alloc] init]];
[a contains: [[NSString alloc] init]]; [a contains: [[NSString alloc] init]];
doStuff(a); // expected-warning {{Conversion}} doStuff(a); // expected-warning {{Conversion}}
[a addObject: [[NSNumber alloc] init]]; // expected-warning {{Conversion from value of type 'NSNumber *' to incompatible type 'NSString *'}}
} }
void idErasedIncompatibleTypesReverseConversion(id a, NSArray<NSString *> *b) { void idErasedIncompatibleTypesReverseConversion(id a, NSMutableArray<NSString *> *b) {
b = a; b = a;
[a contains: [[NSNumber alloc] init]]; // expected-warning {{Conversion}} [a contains: [[NSNumber alloc] init]];
[a contains: [[NSString alloc] init]]; [a contains: [[NSString alloc] init]];
doStuff(a); // expected-warning {{Conversion}} doStuff(a); // expected-warning {{Conversion}}
[a addObject:[[NSNumber alloc] init]]; // expected-warning {{Conversion from value of type 'NSNumber *' to incompatible type 'NSString *'}}
} }
void idErasedIncompatibleTypes(id a, NSArray<NSString *> *b, void idErasedIncompatibleTypes(id a, NSMutableArray<NSString *> *b,
NSArray<NSNumber *> *c) { NSArray<NSNumber *> *c) {
a = b; a = b;
c = a; // expected-warning {{Conversion}} c = a; // expected-warning {{Conversion}}
[a contains: [[NSNumber alloc] init]]; // expected-warning {{Conversion}} [a contains: [[NSNumber alloc] init]];
[a contains: [[NSString alloc] init]]; [a contains: [[NSString alloc] init]];
doStuff(a); // expected-warning {{Conversion}} doStuff(a); // expected-warning {{Conversion}}
[a addObject:[[NSNumber alloc] init]]; // expected-warning {{Conversion from value of type 'NSNumber *' to incompatible type 'NSString *'}}
} }
void pathSensitiveInference(MutableArray *m, MutableArray<NSString *> *a, void pathSensitiveInference(MutableArray *m, MutableArray<NSString *> *a,
MutableArray<NSMutableString *> *b) { MutableArray<NSMutableString *> *b) {
if (getUnknown() == 5) { if (getUnknown() == 5) {
m = a; m = a;
[m contains: [[NSString alloc] init]]; [m contains: [[NSString alloc] init]];
} else { } else {
Show All 23 Linesvoid subtypeOfGeneric(id d, MyMutableStringArray *a,
c = d; // expected-warning {{Conversion}} c = d; // expected-warning {{Conversion}}
} }
void genericSubtypeOfGeneric(id d, ExceptionalArray<NSString *> *a, void genericSubtypeOfGeneric(id d, ExceptionalArray<NSString *> *a,
MutableArray<NSString *> *b, MutableArray<NSString *> *b,
MutableArray<NSNumber *> *c) { MutableArray<NSNumber *> *c) {
d = a; d = a;
[d contains: [[NSString alloc] init]]; [d contains: [[NSString alloc] init]];
[d contains: [[NSNumber alloc] init]]; // expected-warning {{Conversion}} [d contains: [[NSNumber alloc] init]];
b = d; b = d;
c = d; // expected-warning {{Conversion}} c = d; // expected-warning {{Conversion}}
[d addObject: [[NSNumber alloc] init]]; // expected-warning {{Conversion from value of type 'NSNumber *' to incompatible type 'NSString *'}}
} }
void genericSubtypeOfGenericReverse(id d, ExceptionalArray<NSString *> *a, void genericSubtypeOfGenericReverse(id d, ExceptionalArray<NSString *> *a,
MutableArray<NSString *> *b, MutableArray<NSString *> *b,
MutableArray<NSNumber *> *c) { MutableArray<NSNumber *> *c) {
a = d; a = d;
[d contains: [[NSString alloc] init]]; [d contains: [[NSString alloc] init]];
[d contains: [[NSNumber alloc] init]]; // expected-warning {{Conversion}} [d contains: [[NSNumber alloc] init]];
b = d; b = d;
c = d; // expected-warning {{Conversion}} c = d; // expected-warning {{Conversion}}
[d addObject: [[NSNumber alloc] init]]; // expected-warning {{Conversion from value of type 'NSNumber *' to incompatible type 'NSString *'}}
} }
void inferenceFromAPI(id a) { void inferenceFromAPI(id a) {
// Here the type parameter is invariant. There should be a warning every time // Here the type parameter is invariant. There should be a warning every time
// when the type parameter changes during the conversions. // when the type parameter changes during the conversions.
withMutArrString(a); withMutArrString(a);
withMutArrMutableString(a); // expected-warning {{Conversion}} withMutArrMutableString(a); // expected-warning {{Conversion}}
} }
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Linesvoid testUnannotatedLiterals() {
// ObjCArrayLiterals are not specialized in the AST. // ObjCArrayLiterals are not specialized in the AST.
NSArray *arr = @[@"A", @"B"]; NSArray *arr = @[@"A", @"B"];
[arr contains: [[NSNumber alloc] init]]; [arr contains: [[NSNumber alloc] init]];
} }
void testAnnotatedLiterals() { void testAnnotatedLiterals() {
NSArray<NSString *> *arr = @[@"A", @"B"]; NSArray<NSString *> *arr = @[@"A", @"B"];
NSArray *arr2 = arr; NSArray *arr2 = arr;
[arr2 contains: [[NSNumber alloc] init]]; // expected-warning {{Conversion}} [arr2 contains: [[NSNumber alloc] init]];
} }
void nonExistentMethodDoesNotCrash(id a, MutableArray<NSMutableString *> *b) { void nonExistentMethodDoesNotCrash(id a, MutableArray<NSMutableString *> *b) {
a = b; a = b;
[a nonExistentMethod]; [a nonExistentMethod];
} }
void trackedClassVariables() { void trackedClassVariables() {
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesvoid testGetMostInformativeDerivedForId(NSArray<NSString *> *a,
a = idB; // expected-warning {{Conversion from value of type 'UnrelatedTypeGeneric<NSString *> *' to incompatible type 'NSArray<NSString *> *'}} a = idB; // expected-warning {{Conversion from value of type 'UnrelatedTypeGeneric<NSString *> *' to incompatible type 'NSArray<NSString *> *'}}
// rdar://problem/26086914 crash here caused by symbolic type being unrelated // rdar://problem/26086914 crash here caused by symbolic type being unrelated
// to compile-time source type of cast. // to compile-time source type of cast.
id x = a; // Compile-time type is NSArray<>, Symbolic type is UnrelatedTypeGeneric<>. id x = a; // Compile-time type is NSArray<>, Symbolic type is UnrelatedTypeGeneric<>.
[x takesType:[[NSNumber alloc] init]]; // expected-warning {{Conversion from value of type 'NSNumber *' to incompatible type 'NSString *'}} [x takesType:[[NSNumber alloc] init]]; // expected-warning {{Conversion from value of type 'NSNumber *' to incompatible type 'NSString *'}}
} }
void testArgumentAfterUpcastToRootWithCovariantTypeParameter(NSArray<NSString *> *allStrings, NSNumber *number) {
NSArray<NSObject *> *allObjects = allStrings; // no-warning
NSArray<NSObject *> *moreObjects = [allObjects arrayByAddingObject:number]; // no-warning
}
void testArgumentAfterUpcastWithCovariantTypeParameter(NSArray<NSMutableString *> *allMutableStrings, NSNumber *number) {
NSArray<NSString *> *allStrings = allMutableStrings; // no-warning
id numberAsId = number;
NSArray<NSString *> *moreStrings = [allStrings arrayByAddingObject:numberAsId]; // Sema: expected-warning {{Object has a dynamic type 'NSNumber *' which is incompatible with static type 'NSString *'}}
}
void testArgumentAfterCastToUnspecializedWithCovariantTypeParameter(NSArray<NSMutableString *> *allMutableStrings, NSNumber *number) {
NSArray *allStrings = allMutableStrings; // no-warning
id numberAsId = number;
NSArray *moreStringsUnspecialized = [allStrings arrayByAddingObject:numberAsId]; // no-warning
// Ideally the analyzer would warn here.
NSArray<NSString *> *moreStringsSpecialized = [allStrings arrayByAddingObject:numberAsId];
}
void testCallToMethodWithCovariantParameterOnInstanceOfSubclassWithInvariantParameter(NSMutableArray<NSMutableString *> *mutableArrayOfMutableStrings, NSString *someString) {
NSArray<NSString *> *arrayOfStrings = mutableArrayOfMutableStrings;
[arrayOfStrings containsObject:someString]; // no-warning
}
// CHECK: <key>diagnostics</key> // CHECK: <key>diagnostics</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>9632a21d129601d531e0b4585a27c686</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>33d4584e2bf66b029ab9d152cc9cd8f7</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErased</string> // CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErased</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>93</integer> // CHECK-NEXT: <key>line</key><integer>101</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>94</integer> // CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>94</integer> // CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>94</integer> // CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>94</integer> // CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>94</integer> // CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>3c9499ea9f5adc148d5c4b684e3dcc5a</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>6edc910aaa9dc1f2d823abc8cb75360f</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErased</string> // CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErased</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>5</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>94</integer> // CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;NSArray *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>92</integer> // CHECK-NEXT: <key>line</key><integer>100</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer> // CHECK-NEXT: <key>line</key><integer>107</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer> // CHECK-NEXT: <key>line</key><integer>107</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer> // CHECK-NEXT: <key>line</key><integer>107</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer> // CHECK-NEXT: <key>line</key><integer>107</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>17</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer> // CHECK-NEXT: <key>line</key><integer>107</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>39</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>1d8497465a98d7cc2067a916e217d5bc</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>73c71c858082f5d7a2258f707927da3c</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErased</string> // CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErased</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>5</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>8</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>96</integer> // CHECK-NEXT: <key>line</key><integer>107</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>40</integer> // CHECK-NEXT: <key>col</key><integer>40</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>42</integer> // CHECK-NEXT: <key>col</key><integer>42</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Calling &apos;getTypedStuff&apos;</string> // CHECK-NEXT: <string>Calling &apos;getTypedStuff&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Calling &apos;getTypedStuff&apos;</string> // CHECK-NEXT: <string>Calling &apos;getTypedStuff&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>line</key><integer>86</integer>
// CHECK-NEXT: <key>col</key><integer>1</integer> // CHECK-NEXT: <key>col</key><integer>1</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>depth</key><integer>1</integer> // CHECK-NEXT: <key>depth</key><integer>1</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Entered call from &apos;crossProceduralErasedTypes&apos;</string> // CHECK-NEXT: <string>Entered call from &apos;crossProceduralErasedTypes&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Entered call from &apos;crossProceduralErasedTypes&apos;</string> // CHECK-NEXT: <string>Entered call from &apos;crossProceduralErasedTypes&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>line</key><integer>86</integer>
// CHECK-NEXT: <key>col</key><integer>1</integer> // CHECK-NEXT: <key>col</key><integer>1</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>79</integer> // CHECK-NEXT: <key>line</key><integer>86</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>80</integer> // CHECK-NEXT: <key>line</key><integer>87</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>80</integer> // CHECK-NEXT: <key>line</key><integer>87</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>80</integer> // CHECK-NEXT: <key>line</key><integer>87</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>80</integer> // CHECK-NEXT: <key>line</key><integer>87</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>80</integer> // CHECK-NEXT: <key>line</key><integer>87</integer>
// CHECK-NEXT: <key>col</key><integer>37</integer> // CHECK-NEXT: <key>col</key><integer>37</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>1</integer> // CHECK-NEXT: <key>depth</key><integer>1</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSNumber *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSNumber *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSNumber *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSNumber *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSNumber *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSNumber *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSNumber *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSNumber *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>80</integer> // CHECK-NEXT: <key>line</key><integer>87</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>80</integer> // CHECK-NEXT: <key>line</key><integer>87</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>81</integer> // CHECK-NEXT: <key>line</key><integer>88</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>81</integer> // CHECK-NEXT: <key>line</key><integer>88</integer>
// CHECK-NEXT: <key>col</key><integer>8</integer> // CHECK-NEXT: <key>col</key><integer>8</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>42</integer> // CHECK-NEXT: <key>col</key><integer>42</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Returning from &apos;getTypedStuff&apos;</string> // CHECK-NEXT: <string>Returning from &apos;getTypedStuff&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Returning from &apos;getTypedStuff&apos;</string> // CHECK-NEXT: <string>Returning from &apos;getTypedStuff&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>42</integer> // CHECK-NEXT: <key>col</key><integer>42</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSNumber *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSNumber *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSNumber *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSNumber *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSNumber *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSNumber *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>82c378fdcfcc5c0318d2f3ca46420ec1</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>82c378fdcfcc5c0318d2f3ca46420ec1</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>crossProceduralErasedTypes</string> // CHECK-NEXT: <key>issue_context</key><string>crossProceduralErasedTypes</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>1</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>1</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>100</integer> // CHECK-NEXT: <key>line</key><integer>111</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray *&apos; to &apos;NSMutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray *&apos; to &apos;NSMutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>106</integer> // CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>106</integer> // CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>106</integer> // CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>106</integer> // CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>106</integer> // CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>97a49604cb3d640307a104f14b6d950d</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>234e3c299ee75a4dd4563e0ea88b9ed9</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErasedReverseConversion</string> // CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErasedReverseConversion</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>106</integer> // CHECK-NEXT: <key>line</key><integer>119</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray *&apos; to &apos;NSMutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray *&apos; to &apos;NSMutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer> // CHECK-NEXT: <key>line</key><integer>116</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer> // CHECK-NEXT: <key>line</key><integer>121</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer> // CHECK-NEXT: <key>line</key><integer>121</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer> // CHECK-NEXT: <key>line</key><integer>121</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer> // CHECK-NEXT: <key>line</key><integer>121</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>17</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer> // CHECK-NEXT: <key>line</key><integer>121</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>39</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>b358a659d36c93a9fba593cf6d866a2b</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>e875afc5479fec33a693ce2b550a9573</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErasedReverseConversion</string> // CHECK-NEXT: <key>issue_context</key><string>incompatibleTypesErasedReverseConversion</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>6</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>108</integer> // CHECK-NEXT: <key>line</key><integer>121</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;NSMutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;NSMutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>113</integer> // CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>113</integer> // CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>113</integer> // CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>113</integer> // CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>113</integer> // CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>a57d9309397250421e9b96afe80c2045</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>d7fa9fa89fe860ed8f5d22631233a5fa</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypesReverseConversion</string> // CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypesReverseConversion</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>113</integer> // CHECK-NEXT: <key>line</key><integer>128</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;NSMutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;NSMutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>112</integer> // CHECK-NEXT: <key>line</key><integer>125</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer> // CHECK-NEXT: <key>line</key><integer>130</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer> // CHECK-NEXT: <key>line</key><integer>130</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer> // CHECK-NEXT: <key>line</key><integer>130</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer> // CHECK-NEXT: <key>line</key><integer>130</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer> // CHECK-NEXT: <key>line</key><integer>130</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>38</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>3c86c79284e67f28d04b7ef88bedbb8b</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>7de91182a5d6e40a85fa3b91cf3fd089</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypesReverseConversion</string> // CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypesReverseConversion</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>6</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>115</integer> // CHECK-NEXT: <key>line</key><integer>130</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>a669a3ca1da5a07458c0186f43a295cb</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>8960776d84319407ac2bf7a1531d19b0</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypes</string> // CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypes</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>121</integer> // CHECK-NEXT: <key>line</key><integer>136</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>122</integer> // CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>122</integer> // CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>122</integer> // CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>122</integer> // CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>122</integer> // CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSMutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>7ab912bd3fb03b47dc9489cac0297e2a</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>93b114c7a385294dce5c25ed04a8b25a</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypes</string> // CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypes</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>5</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>122</integer> // CHECK-NEXT: <key>line</key><integer>139</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSMutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSMutableArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>120</integer> // CHECK-NEXT: <key>line</key><integer>135</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer> // CHECK-NEXT: <key>line</key><integer>141</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer> // CHECK-NEXT: <key>line</key><integer>141</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer> // CHECK-NEXT: <key>line</key><integer>141</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer> // CHECK-NEXT: <key>line</key><integer>141</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer> // CHECK-NEXT: <key>line</key><integer>141</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>38</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>0c7b4313b8b720c914b04863f47f971f</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>4c17f22d7e977f3343d2e2129b9229c3</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypes</string> // CHECK-NEXT: <key>issue_context</key><string>idErasedIncompatibleTypes</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>5</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>7</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>124</integer> // CHECK-NEXT: <key>line</key><integer>141</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>line</key><integer>146</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>line</key><integer>146</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>line</key><integer>146</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>line</key><integer>146</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>line</key><integer>146</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>line</key><integer>146</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>line</key><integer>146</integer>
// CHECK-NEXT: <key>col</key><integer>23</integer> // CHECK-NEXT: <key>col</key><integer>23</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Assuming the condition is false</string> // CHECK-NEXT: <string>Assuming the condition is false</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Assuming the condition is false</string> // CHECK-NEXT: <string>Assuming the condition is false</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>line</key><integer>146</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>129</integer> // CHECK-NEXT: <key>line</key><integer>146</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>133</integer> // CHECK-NEXT: <key>line</key><integer>150</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>133</integer> // CHECK-NEXT: <key>line</key><integer>150</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>133</integer> // CHECK-NEXT: <key>line</key><integer>150</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>133</integer> // CHECK-NEXT: <key>line</key><integer>150</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>133</integer> // CHECK-NEXT: <key>line</key><integer>150</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>133</integer> // CHECK-NEXT: <key>line</key><integer>150</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>133</integer> // CHECK-NEXT: <key>line</key><integer>150</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>134</integer> // CHECK-NEXT: <key>line</key><integer>151</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>134</integer> // CHECK-NEXT: <key>line</key><integer>151</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>134</integer> // CHECK-NEXT: <key>line</key><integer>151</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>134</integer> // CHECK-NEXT: <key>line</key><integer>151</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>136</integer> // CHECK-NEXT: <key>line</key><integer>153</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>136</integer> // CHECK-NEXT: <key>line</key><integer>153</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>136</integer> // CHECK-NEXT: <key>line</key><integer>153</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>136</integer> // CHECK-NEXT: <key>line</key><integer>153</integer>
// CHECK-NEXT: <key>col</key><integer>17</integer> // CHECK-NEXT: <key>col</key><integer>17</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>136</integer> // CHECK-NEXT: <key>line</key><integer>153</integer>
// CHECK-NEXT: <key>col</key><integer>39</integer> // CHECK-NEXT: <key>col</key><integer>39</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>24a08781e7d8971a7d8f8f607ce40074</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>24a08781e7d8971a7d8f8f607ce40074</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>pathSensitiveInference</string> // CHECK-NEXT: <key>issue_context</key><string>pathSensitiveInference</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>8</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>8</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>136</integer> // CHECK-NEXT: <key>line</key><integer>153</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>141</integer> // CHECK-NEXT: <key>line</key><integer>158</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>141</integer> // CHECK-NEXT: <key>line</key><integer>158</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>141</integer> // CHECK-NEXT: <key>line</key><integer>158</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>141</integer> // CHECK-NEXT: <key>line</key><integer>158</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>141</integer> // CHECK-NEXT: <key>line</key><integer>158</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>a8534f675404d57d833dc3c371d49845</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>a8534f675404d57d833dc3c371d49845</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>verifyAPIusage</string> // CHECK-NEXT: <key>issue_context</key><string>verifyAPIusage</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>142</integer> // CHECK-NEXT: <key>line</key><integer>159</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>147</integer> // CHECK-NEXT: <key>line</key><integer>164</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>147</integer> // CHECK-NEXT: <key>line</key><integer>164</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>147</integer> // CHECK-NEXT: <key>line</key><integer>164</integer>
// CHECK-NEXT: <key>col</key><integer>42</integer> // CHECK-NEXT: <key>col</key><integer>42</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from explicit cast (from &apos;MutableArray *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from explicit cast (from &apos;MutableArray *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from explicit cast (from &apos;MutableArray *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from explicit cast (from &apos;MutableArray *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>147</integer> // CHECK-NEXT: <key>line</key><integer>164</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>147</integer> // CHECK-NEXT: <key>line</key><integer>164</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>148</integer> // CHECK-NEXT: <key>line</key><integer>165</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>148</integer> // CHECK-NEXT: <key>line</key><integer>165</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>148</integer> // CHECK-NEXT: <key>line</key><integer>165</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>148</integer> // CHECK-NEXT: <key>line</key><integer>165</integer>
// CHECK-NEXT: <key>col</key><integer>17</integer> // CHECK-NEXT: <key>col</key><integer>17</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>148</integer> // CHECK-NEXT: <key>line</key><integer>165</integer>
// CHECK-NEXT: <key>col</key><integer>39</integer> // CHECK-NEXT: <key>col</key><integer>39</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>0549631e5a7fa668375061b6c898e438</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>0549631e5a7fa668375061b6c898e438</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>trustExplicitCasts</string> // CHECK-NEXT: <key>issue_context</key><string>trustExplicitCasts</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>148</integer> // CHECK-NEXT: <key>line</key><integer>165</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>154</integer> // CHECK-NEXT: <key>line</key><integer>171</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>154</integer> // CHECK-NEXT: <key>line</key><integer>171</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>155</integer> // CHECK-NEXT: <key>line</key><integer>172</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>155</integer> // CHECK-NEXT: <key>line</key><integer>172</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>155</integer> // CHECK-NEXT: <key>line</key><integer>172</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>155</integer> // CHECK-NEXT: <key>line</key><integer>172</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>155</integer> // CHECK-NEXT: <key>line</key><integer>172</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>155</integer> // CHECK-NEXT: <key>line</key><integer>172</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>155</integer> // CHECK-NEXT: <key>line</key><integer>172</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>d113e22b9ee9ded1cd94750c3557eff4</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>d113e22b9ee9ded1cd94750c3557eff4</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>subtypeOfGeneric</string> // CHECK-NEXT: <key>issue_context</key><string>subtypeOfGeneric</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>156</integer> // CHECK-NEXT: <key>line</key><integer>173</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>164</integer> // CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>164</integer> // CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>164</integer> // CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>164</integer> // CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>164</integer> // CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>22fad8121164716006b2a12f4ddc494e</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>f1b900572a63726a729714a765595c38</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>genericSubtypeOfGeneric</string> // CHECK-NEXT: <key>issue_context</key><string>genericSubtypeOfGeneric</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>5</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>164</integer> // CHECK-NEXT: <key>line</key><integer>183</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>162</integer> // CHECK-NEXT: <key>line</key><integer>179</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer> // CHECK-NEXT: <key>line</key><integer>185</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer> // CHECK-NEXT: <key>line</key><integer>185</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer> // CHECK-NEXT: <key>line</key><integer>185</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer> // CHECK-NEXT: <key>line</key><integer>185</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>17</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer> // CHECK-NEXT: <key>line</key><integer>185</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>39</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>f1b900572a63726a729714a765595c38</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>cbb926c9de226a3eac85fb961a93f39a</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>genericSubtypeOfGeneric</string> // CHECK-NEXT: <key>issue_context</key><string>genericSubtypeOfGeneric</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>5</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>7</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>166</integer> // CHECK-NEXT: <key>line</key><integer>185</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;ExceptionalArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;ExceptionalArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;ExceptionalArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;ExceptionalArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>174</integer> // CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>174</integer> // CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>174</integer> // CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>174</integer> // CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>174</integer> // CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>c70c13fbce3e6a90637decd9d0e19d95</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>b6ee3b22fbad45f213b4bf14bec7eeaf</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>genericSubtypeOfGenericReverse</string> // CHECK-NEXT: <key>issue_context</key><string>genericSubtypeOfGenericReverse</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>5</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>174</integer> // CHECK-NEXT: <key>line</key><integer>195</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;ExceptionalArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;ExceptionalArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;ExceptionalArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;ExceptionalArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>172</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer> // CHECK-NEXT: <key>line</key><integer>191</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer> // CHECK-NEXT: <key>line</key><integer>197</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>2</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer> // CHECK-NEXT: <key>line</key><integer>197</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>2</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer> // CHECK-NEXT: <key>line</key><integer>197</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>2</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer> // CHECK-NEXT: <key>line</key><integer>197</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer> // CHECK-NEXT: <key>line</key><integer>197</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>38</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;ExceptionalArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>b6ee3b22fbad45f213b4bf14bec7eeaf</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>6561f05506a8ceca3afc79fc59912b94</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>genericSubtypeOfGenericReverse</string> // CHECK-NEXT: <key>issue_context</key><string>genericSubtypeOfGenericReverse</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>5</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>7</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>176</integer> // CHECK-NEXT: <key>line</key><integer>197</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>2</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>182</integer> // CHECK-NEXT: <key>line</key><integer>203</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>182</integer> // CHECK-NEXT: <key>line</key><integer>203</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>182</integer> // CHECK-NEXT: <key>line</key><integer>203</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>182</integer> // CHECK-NEXT: <key>line</key><integer>203</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>182</integer> // CHECK-NEXT: <key>line</key><integer>203</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>6aab15d40b39ec0a6b749e561d486e6a</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>6aab15d40b39ec0a6b749e561d486e6a</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPI</string> // CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPI</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>183</integer> // CHECK-NEXT: <key>line</key><integer>204</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>187</integer> // CHECK-NEXT: <key>line</key><integer>208</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>187</integer> // CHECK-NEXT: <key>line</key><integer>208</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>187</integer> // CHECK-NEXT: <key>line</key><integer>208</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;id&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>187</integer> // CHECK-NEXT: <key>line</key><integer>208</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>187</integer> // CHECK-NEXT: <key>line</key><integer>208</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>bd1da1b7775323773555e5d5c122661f</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>bd1da1b7775323773555e5d5c122661f</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPI2</string> // CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPI2</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>188</integer> // CHECK-NEXT: <key>line</key><integer>209</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>192</integer> // CHECK-NEXT: <key>line</key><integer>213</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>192</integer> // CHECK-NEXT: <key>line</key><integer>213</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>192</integer> // CHECK-NEXT: <key>line</key><integer>213</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacyMutableArray *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacyMutableArray *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacyMutableArray *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacyMutableArray *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>192</integer> // CHECK-NEXT: <key>line</key><integer>213</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>192</integer> // CHECK-NEXT: <key>line</key><integer>213</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>3f2abd3c0b4b4a80a71bcbb668124ffb</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>3f2abd3c0b4b4a80a71bcbb668124ffb</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPIWithLegacyTypes</string> // CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPIWithLegacyTypes</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>193</integer> // CHECK-NEXT: <key>line</key><integer>214</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>197</integer> // CHECK-NEXT: <key>line</key><integer>218</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>197</integer> // CHECK-NEXT: <key>line</key><integer>218</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>197</integer> // CHECK-NEXT: <key>line</key><integer>218</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacySpecialMutableArray *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacySpecialMutableArray *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacySpecialMutableArray *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacySpecialMutableArray *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>197</integer> // CHECK-NEXT: <key>line</key><integer>218</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>197</integer> // CHECK-NEXT: <key>line</key><integer>218</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>73a50f2592e8b3c9af898749f24176f7</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>73a50f2592e8b3c9af898749f24176f7</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPIWithLegacyTypes2</string> // CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPIWithLegacyTypes2</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>198</integer> // CHECK-NEXT: <key>line</key><integer>219</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>202</integer> // CHECK-NEXT: <key>line</key><integer>223</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>202</integer> // CHECK-NEXT: <key>line</key><integer>223</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>202</integer> // CHECK-NEXT: <key>line</key><integer>223</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;__kindof NSArray&lt;NSString *&gt; *&apos; to &apos;LegacyMutableArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;__kindof NSArray&lt;NSString *&gt; *&apos; to &apos;LegacyMutableArray *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;__kindof NSArray&lt;NSString *&gt; *&apos; to &apos;LegacyMutableArray *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;__kindof NSArray&lt;NSString *&gt; *&apos; to &apos;LegacyMutableArray *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>202</integer> // CHECK-NEXT: <key>line</key><integer>223</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>202</integer> // CHECK-NEXT: <key>line</key><integer>223</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>203</integer> // CHECK-NEXT: <key>line</key><integer>224</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>203</integer> // CHECK-NEXT: <key>line</key><integer>224</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>203</integer> // CHECK-NEXT: <key>line</key><integer>224</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>203</integer> // CHECK-NEXT: <key>line</key><integer>224</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>203</integer> // CHECK-NEXT: <key>line</key><integer>224</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacyMutableArray *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacyMutableArray *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacyMutableArray *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;LegacyMutableArray *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>203</integer> // CHECK-NEXT: <key>line</key><integer>224</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>203</integer> // CHECK-NEXT: <key>line</key><integer>224</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>23ca540c8961ab9a362a194e1e895f86</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>23ca540c8961ab9a362a194e1e895f86</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPIWithLegacyTypes3</string> // CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPIWithLegacyTypes3</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>204</integer> // CHECK-NEXT: <key>line</key><integer>225</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>208</integer> // CHECK-NEXT: <key>line</key><integer>229</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>208</integer> // CHECK-NEXT: <key>line</key><integer>229</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>208</integer> // CHECK-NEXT: <key>line</key><integer>229</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>208</integer> // CHECK-NEXT: <key>line</key><integer>229</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>208</integer> // CHECK-NEXT: <key>line</key><integer>229</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>be7e9426f827314f05fd4e15b25909df</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>be7e9426f827314f05fd4e15b25909df</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPIWithBuggyTypes</string> // CHECK-NEXT: <key>issue_context</key><string>inferenceFromAPIWithBuggyTypes</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>209</integer> // CHECK-NEXT: <key>line</key><integer>230</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>213</integer> // CHECK-NEXT: <key>line</key><integer>234</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>213</integer> // CHECK-NEXT: <key>line</key><integer>234</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>213</integer> // CHECK-NEXT: <key>line</key><integer>234</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggySpecialMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggySpecialMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggySpecialMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggySpecialMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>213</integer> // CHECK-NEXT: <key>line</key><integer>234</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>213</integer> // CHECK-NEXT: <key>line</key><integer>234</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>0f97a618ccac913d7c8631b5b86a133e</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>0f97a618ccac913d7c8631b5b86a133e</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>InferenceFromAPIWithBuggyTypes2</string> // CHECK-NEXT: <key>issue_context</key><string>InferenceFromAPIWithBuggyTypes2</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>214</integer> // CHECK-NEXT: <key>line</key><integer>235</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>218</integer> // CHECK-NEXT: <key>line</key><integer>239</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>218</integer> // CHECK-NEXT: <key>line</key><integer>239</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>218</integer> // CHECK-NEXT: <key>line</key><integer>239</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>218</integer> // CHECK-NEXT: <key>line</key><integer>239</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>218</integer> // CHECK-NEXT: <key>line</key><integer>239</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>725c54c88bb271138b1de545ee59a8aa</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>725c54c88bb271138b1de545ee59a8aa</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>InferenceFromAPIWithBuggyTypes3</string> // CHECK-NEXT: <key>issue_context</key><string>InferenceFromAPIWithBuggyTypes3</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>220</integer> // CHECK-NEXT: <key>line</key><integer>241</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>224</integer> // CHECK-NEXT: <key>line</key><integer>245</integer>
// CHECK-NEXT: <key>col</key><integer>45</integer> // CHECK-NEXT: <key>col</key><integer>45</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>224</integer> // CHECK-NEXT: <key>line</key><integer>245</integer>
// CHECK-NEXT: <key>col</key><integer>45</integer> // CHECK-NEXT: <key>col</key><integer>45</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>224</integer> // CHECK-NEXT: <key>line</key><integer>245</integer>
// CHECK-NEXT: <key>col</key><integer>45</integer> // CHECK-NEXT: <key>col</key><integer>45</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;__kindof NSArray&lt;NSString *&gt; *&apos; to &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;__kindof NSArray&lt;NSString *&gt; *&apos; to &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;__kindof NSArray&lt;NSString *&gt; *&apos; to &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;__kindof NSArray&lt;NSString *&gt; *&apos; to &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>224</integer> // CHECK-NEXT: <key>line</key><integer>245</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>224</integer> // CHECK-NEXT: <key>line</key><integer>245</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>225</integer> // CHECK-NEXT: <key>line</key><integer>246</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>225</integer> // CHECK-NEXT: <key>line</key><integer>246</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>225</integer> // CHECK-NEXT: <key>line</key><integer>246</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>225</integer> // CHECK-NEXT: <key>line</key><integer>246</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>225</integer> // CHECK-NEXT: <key>line</key><integer>246</integer>
// CHECK-NEXT: <key>col</key><integer>20</integer> // CHECK-NEXT: <key>col</key><integer>20</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;BuggyMutableArray&lt;NSMutableString *&gt; *&apos; to &apos;MutableArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>225</integer> // CHECK-NEXT: <key>line</key><integer>246</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>225</integer> // CHECK-NEXT: <key>line</key><integer>246</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>25</integer> // CHECK-NEXT: <key>col</key><integer>25</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;MutableArray&lt;NSString *&gt; *&apos; to incompatible type &apos;MutableArray&lt;NSMutableString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>fb867af384c612fe5c09f821127eeaf0</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>fb867af384c612fe5c09f821127eeaf0</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>InferenceFromAPIWithBuggyTypes4</string> // CHECK-NEXT: <key>issue_context</key><string>InferenceFromAPIWithBuggyTypes4</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>226</integer> // CHECK-NEXT: <key>line</key><integer>247</integer>
// CHECK-NEXT: <key>col</key><integer>27</integer> // CHECK-NEXT: <key>col</key><integer>27</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>238</integer> // CHECK-NEXT: <key>line</key><integer>259</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>238</integer> // CHECK-NEXT: <key>line</key><integer>259</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>38</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>38</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Type Error</string> // CHECK-NEXT: <key>category</key><string>Type Error</string>
// CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string> // CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string>
// CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string> // CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>2e9f738345d9fa7dae2324ff7accd1ae</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>2e9f738345d9fa7dae2324ff7accd1ae</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>workWithProperties</string> // CHECK-NEXT: <key>issue_context</key><string>workWithProperties</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>239</integer> // CHECK-NEXT: <key>line</key><integer>260</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>238</integer> // CHECK-NEXT: <key>line</key><integer>259</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>238</integer> // CHECK-NEXT: <key>line</key><integer>259</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>23</integer> // CHECK-NEXT: <key>col</key><integer>23</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>23</integer> // CHECK-NEXT: <key>col</key><integer>23</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Type Error</string> // CHECK-NEXT: <key>category</key><string>Type Error</string>
// CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string> // CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string>
// CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string> // CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>d85392b4efadf710b8da65a043a65e24</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>d85392b4efadf710b8da65a043a65e24</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>workWithProperties</string> // CHECK-NEXT: <key>issue_context</key><string>workWithProperties</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>241</integer> // CHECK-NEXT: <key>line</key><integer>262</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>238</integer> // CHECK-NEXT: <key>line</key><integer>259</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>238</integer> // CHECK-NEXT: <key>line</key><integer>259</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>21</integer> // CHECK-NEXT: <key>col</key><integer>21</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>11</integer> // CHECK-NEXT: <key>col</key><integer>11</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>21</integer> // CHECK-NEXT: <key>col</key><integer>21</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>21</integer> // CHECK-NEXT: <key>col</key><integer>21</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Type Error</string> // CHECK-NEXT: <key>category</key><string>Type Error</string>
// CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string> // CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string>
// CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string> // CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>456c6227549a5e577088c9dce4cea452</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>456c6227549a5e577088c9dce4cea452</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>workWithProperties</string> // CHECK-NEXT: <key>issue_context</key><string>workWithProperties</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>6</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>6</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>243</integer> // CHECK-NEXT: <key>line</key><integer>264</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>238</integer> // CHECK-NEXT: <key>line</key><integer>259</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>238</integer> // CHECK-NEXT: <key>line</key><integer>259</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSNumber *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>col</key><integer>12</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Type Error</string> // CHECK-NEXT: <key>category</key><string>Type Error</string>
// CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string> // CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string>
// CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string> // CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>df7f090d2b72ac07bc2351177ed6552d</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>df7f090d2b72ac07bc2351177ed6552d</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>workWithProperties</string> // CHECK-NEXT: <key>issue_context</key><string>workWithProperties</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>8</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>8</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>245</integer> // CHECK-NEXT: <key>line</key><integer>266</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>251</integer> // CHECK-NEXT: <key>line</key><integer>272</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>251</integer> // CHECK-NEXT: <key>line</key><integer>272</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>251</integer> // CHECK-NEXT: <key>line</key><integer>272</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;NSArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;NSArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;NSArray&lt;NSMutableString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;NSArray&lt;NSMutableString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>251</integer> // CHECK-NEXT: <key>line</key><integer>272</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>251</integer> // CHECK-NEXT: <key>line</key><integer>272</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>23</integer> // CHECK-NEXT: <key>col</key><integer>23</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Assuming the condition is true</string> // CHECK-NEXT: <string>Assuming the condition is true</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Assuming the condition is true</string> // CHECK-NEXT: <string>Assuming the condition is true</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>252</integer> // CHECK-NEXT: <key>line</key><integer>273</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>253</integer> // CHECK-NEXT: <key>line</key><integer>274</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>253</integer> // CHECK-NEXT: <key>line</key><integer>274</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>253</integer> // CHECK-NEXT: <key>line</key><integer>274</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>253</integer> // CHECK-NEXT: <key>line</key><integer>274</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>254</integer> // CHECK-NEXT: <key>line</key><integer>275</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>254</integer> // CHECK-NEXT: <key>line</key><integer>275</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>254</integer> // CHECK-NEXT: <key>line</key><integer>275</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>254</integer> // CHECK-NEXT: <key>line</key><integer>275</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>254</integer> // CHECK-NEXT: <key>line</key><integer>275</integer>
// CHECK-NEXT: <key>col</key><integer>41</integer> // CHECK-NEXT: <key>col</key><integer>41</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>a0fa75143d7a7ac234292642a6d93360</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>a0fa75143d7a7ac234292642a6d93360</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>findMethodDeclInTrackedType</string> // CHECK-NEXT: <key>issue_context</key><string>findMethodDeclInTrackedType</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>4</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>254</integer> // CHECK-NEXT: <key>line</key><integer>275</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>263</integer> // CHECK-NEXT: <key>line</key><integer>284</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>263</integer> // CHECK-NEXT: <key>line</key><integer>284</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>263</integer> // CHECK-NEXT: <key>line</key><integer>284</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;__kindof NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;__kindof NSArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;__kindof NSArray&lt;NSString *&gt; *&apos;)</string> // CHECK-NEXT: <string>Type &apos;MutableArray&lt;NSMutableString *&gt; *&apos; is inferred from implicit cast (from &apos;MutableArray&lt;NSMutableString *&gt; *&apos; to &apos;__kindof NSArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>263</integer> // CHECK-NEXT: <key>line</key><integer>284</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>263</integer> // CHECK-NEXT: <key>line</key><integer>284</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>23</integer> // CHECK-NEXT: <key>col</key><integer>23</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Assuming the condition is true</string> // CHECK-NEXT: <string>Assuming the condition is true</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Assuming the condition is true</string> // CHECK-NEXT: <string>Assuming the condition is true</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>264</integer> // CHECK-NEXT: <key>line</key><integer>285</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>265</integer> // CHECK-NEXT: <key>line</key><integer>286</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>265</integer> // CHECK-NEXT: <key>line</key><integer>286</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>265</integer> // CHECK-NEXT: <key>line</key><integer>286</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>265</integer> // CHECK-NEXT: <key>line</key><integer>286</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>265</integer> // CHECK-NEXT: <key>line</key><integer>286</integer>
// CHECK-NEXT: <key>col</key><integer>41</integer> // CHECK-NEXT: <key>col</key><integer>41</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSString *&apos; to incompatible type &apos;NSMutableString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>d0b99c8523e81ec43ba4ea80aeedef1b</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>d0b99c8523e81ec43ba4ea80aeedef1b</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>findMethodDeclInTrackedType2</string> // CHECK-NEXT: <key>issue_context</key><string>findMethodDeclInTrackedType2</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>265</integer> // CHECK-NEXT: <key>line</key><integer>286</integer>
// CHECK-NEXT: <key>col</key><integer>5</integer> // CHECK-NEXT: <key>col</key><integer>5</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>278</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>278</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>278</integer>
// CHECK-NEXT: <key>col</key><integer>42</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray *&apos; to &apos;NSArray&lt;NSString *&gt; *&apos;)</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>278</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>278</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>280</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>280</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>280</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>280</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>280</integer>
// CHECK-NEXT: <key>col</key><integer>41</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>ed543d4961e934fb4ac8db00e885fc7f</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>testAnnotatedLiterals</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>280</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>289</integer> // CHECK-NEXT: <key>line</key><integer>310</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>289</integer> // CHECK-NEXT: <key>line</key><integer>310</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>39</integer> // CHECK-NEXT: <key>col</key><integer>39</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>39</integer> // CHECK-NEXT: <key>col</key><integer>39</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>46aa94b866747bcbe1ded581da7a2633</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>46aa94b866747bcbe1ded581da7a2633</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>trackedClassVariables</string> // CHECK-NEXT: <key>issue_context</key><string>trackedClassVariables</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>290</integer> // CHECK-NEXT: <key>line</key><integer>311</integer>
// CHECK-NEXT: <key>col</key><integer>28</integer> // CHECK-NEXT: <key>col</key><integer>28</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>289</integer> // CHECK-NEXT: <key>line</key><integer>310</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>289</integer> // CHECK-NEXT: <key>line</key><integer>310</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>a759006d1ce88e15fcd6de6a29e2579c</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>a759006d1ce88e15fcd6de6a29e2579c</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>trackedClassVariables</string> // CHECK-NEXT: <key>issue_context</key><string>trackedClassVariables</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>291</integer> // CHECK-NEXT: <key>line</key><integer>312</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>295</integer> // CHECK-NEXT: <key>line</key><integer>316</integer>
// CHECK-NEXT: <key>col</key><integer>13</integer> // CHECK-NEXT: <key>col</key><integer>13</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>295</integer> // CHECK-NEXT: <key>line</key><integer>316</integer>
// CHECK-NEXT: <key>col</key><integer>13</integer> // CHECK-NEXT: <key>col</key><integer>13</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>295</integer> // CHECK-NEXT: <key>line</key><integer>316</integer>
// CHECK-NEXT: <key>col</key><integer>15</integer> // CHECK-NEXT: <key>col</key><integer>15</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;NSArray&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>295</integer> // CHECK-NEXT: <key>line</key><integer>316</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>295</integer> // CHECK-NEXT: <key>line</key><integer>316</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>21</integer> // CHECK-NEXT: <key>col</key><integer>21</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>21</integer> // CHECK-NEXT: <key>col</key><integer>21</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>4bb1729ff86647750b458e6f8d883f08</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>4bb1729ff86647750b458e6f8d883f08</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>nestedCollections</string> // CHECK-NEXT: <key>issue_context</key><string>nestedCollections</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>296</integer> // CHECK-NEXT: <key>line</key><integer>317</integer>
// CHECK-NEXT: <key>col</key><integer>18</integer> // CHECK-NEXT: <key>col</key><integer>18</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>308</integer> // CHECK-NEXT: <key>line</key><integer>329</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>308</integer> // CHECK-NEXT: <key>line</key><integer>329</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>309</integer> // CHECK-NEXT: <key>line</key><integer>330</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>309</integer> // CHECK-NEXT: <key>line</key><integer>330</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>309</integer> // CHECK-NEXT: <key>line</key><integer>330</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>309</integer> // CHECK-NEXT: <key>line</key><integer>330</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>309</integer> // CHECK-NEXT: <key>line</key><integer>330</integer>
// CHECK-NEXT: <key>col</key><integer>29</integer> // CHECK-NEXT: <key>col</key><integer>29</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>309</integer> // CHECK-NEXT: <key>line</key><integer>330</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>309</integer> // CHECK-NEXT: <key>line</key><integer>330</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>38831553eaecfb6c02b51e71d21ec6ea</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>38831553eaecfb6c02b51e71d21ec6ea</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>returnCollectionToIdVariable</string> // CHECK-NEXT: <key>issue_context</key><string>returnCollectionToIdVariable</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>310</integer> // CHECK-NEXT: <key>line</key><integer>331</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>314</integer> // CHECK-NEXT: <key>line</key><integer>335</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>314</integer> // CHECK-NEXT: <key>line</key><integer>335</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>315</integer> // CHECK-NEXT: <key>line</key><integer>336</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>315</integer> // CHECK-NEXT: <key>line</key><integer>336</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>315</integer> // CHECK-NEXT: <key>line</key><integer>336</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>315</integer> // CHECK-NEXT: <key>line</key><integer>336</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>315</integer> // CHECK-NEXT: <key>line</key><integer>336</integer>
// CHECK-NEXT: <key>col</key><integer>35</integer> // CHECK-NEXT: <key>col</key><integer>35</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>315</integer> // CHECK-NEXT: <key>line</key><integer>336</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>315</integer> // CHECK-NEXT: <key>line</key><integer>336</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSArray&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSNumber *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>9fcbd4dcf212f004877292aa5085322b</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>9fcbd4dcf212f004877292aa5085322b</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>eraseSpecialization</string> // CHECK-NEXT: <key>issue_context</key><string>eraseSpecialization</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>316</integer> // CHECK-NEXT: <key>line</key><integer>337</integer>
// CHECK-NEXT: <key>col</key><integer>30</integer> // CHECK-NEXT: <key>col</key><integer>30</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>320</integer> // CHECK-NEXT: <key>line</key><integer>341</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>320</integer> // CHECK-NEXT: <key>line</key><integer>341</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>14</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>14</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>14</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>14</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>33</integer> // CHECK-NEXT: <key>col</key><integer>33</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSArray&lt;NSString *&gt; *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>14</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>14</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>33</integer> // CHECK-NEXT: <key>col</key><integer>33</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSArray&lt;NSString *&gt; *&apos; which is incompatible with static type &apos;NSSet *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSArray&lt;NSString *&gt; *&apos; which is incompatible with static type &apos;NSSet *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSArray&lt;NSString *&gt; *&apos; which is incompatible with static type &apos;NSSet *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSArray&lt;NSString *&gt; *&apos; which is incompatible with static type &apos;NSSet *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSArray&lt;NSString *&gt; *&apos; which is incompatible with static type &apos;NSSet *&apos;</string> // CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSArray&lt;NSString *&gt; *&apos; which is incompatible with static type &apos;NSSet *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Type Error</string> // CHECK-NEXT: <key>category</key><string>Type Error</string>
// CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string> // CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string>
// CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string> // CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>be6714fed24af6e7ac522b87a5098de0</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>be6714fed24af6e7ac522b87a5098de0</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>returnToUnrelatedType</string> // CHECK-NEXT: <key>issue_context</key><string>returnToUnrelatedType</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>321</integer> // CHECK-NEXT: <key>line</key><integer>342</integer>
// CHECK-NEXT: <key>col</key><integer>14</integer> // CHECK-NEXT: <key>col</key><integer>14</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>326</integer> // CHECK-NEXT: <key>line</key><integer>347</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>326</integer> // CHECK-NEXT: <key>line</key><integer>347</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>327</integer> // CHECK-NEXT: <key>line</key><integer>348</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>327</integer> // CHECK-NEXT: <key>line</key><integer>348</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>327</integer> // CHECK-NEXT: <key>line</key><integer>348</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>327</integer> // CHECK-NEXT: <key>line</key><integer>348</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>327</integer> // CHECK-NEXT: <key>line</key><integer>348</integer>
// CHECK-NEXT: <key>col</key><integer>29</integer> // CHECK-NEXT: <key>col</key><integer>29</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;NSString *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSString *&apos; is inferred from this context</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;NSString *&apos; is inferred from this context</string> // CHECK-NEXT: <string>Type &apos;NSString *&apos; is inferred from this context</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>327</integer> // CHECK-NEXT: <key>line</key><integer>348</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>327</integer> // CHECK-NEXT: <key>line</key><integer>348</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>10</integer> // CHECK-NEXT: <key>col</key><integer>10</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSString *&apos; which is incompatible with static type &apos;NSNumber *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSString *&apos; which is incompatible with static type &apos;NSNumber *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSString *&apos; which is incompatible with static type &apos;NSNumber *&apos;</string> // CHECK-NEXT: <string>Object has a dynamic type &apos;NSString *&apos; which is incompatible with static type &apos;NSNumber *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSString *&apos; which is incompatible with static type &apos;NSNumber *&apos;</string> // CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSString *&apos; which is incompatible with static type &apos;NSNumber *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Type Error</string> // CHECK-NEXT: <key>category</key><string>Type Error</string>
// CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string> // CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string>
// CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string> // CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>5e96ef711c8f115bc64f69baa3f6ea7a</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>5e96ef711c8f115bc64f69baa3f6ea7a</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>returnToIdVariable</string> // CHECK-NEXT: <key>issue_context</key><string>returnToIdVariable</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>328</integer> // CHECK-NEXT: <key>line</key><integer>349</integer>
// CHECK-NEXT: <key>col</key><integer>19</integer> // CHECK-NEXT: <key>col</key><integer>19</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>col</key><integer>12</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>col</key><integer>12</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>col</key><integer>12</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer> // CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to incompatible type &apos;NSArray&lt;NSString *&gt; *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>8347f65fb51a85ccd462d75ffd761078</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>8347f65fb51a85ccd462d75ffd761078</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>testGetMostInformativeDerivedForId</string> // CHECK-NEXT: <key>issue_context</key><string>testGetMostInformativeDerivedForId</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>2</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>338</integer> // CHECK-NEXT: <key>line</key><integer>359</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer> // CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key> // CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>col</key><integer>12</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>col</key><integer>12</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>12</integer> // CHECK-NEXT: <key>col</key><integer>12</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string> // CHECK-NEXT: <string>Type &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; is inferred from implicit cast (from &apos;UnrelatedTypeGeneric&lt;NSString *&gt; *&apos; to &apos;id&apos;)</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string> // CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key> // CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key> // CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>337</integer> // CHECK-NEXT: <key>line</key><integer>358</integer>
// CHECK-NEXT: <key>col</key><integer>4</integer> // CHECK-NEXT: <key>col</key><integer>4</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key> // CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>343</integer> // CHECK-NEXT: <key>line</key><integer>364</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>343</integer> // CHECK-NEXT: <key>line</key><integer>364</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string> // CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>343</integer> // CHECK-NEXT: <key>line</key><integer>364</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key> // CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <array> // CHECK-NEXT: <array>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>343</integer> // CHECK-NEXT: <key>line</key><integer>364</integer>
// CHECK-NEXT: <key>col</key><integer>16</integer> // CHECK-NEXT: <key>col</key><integer>16</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>343</integer> // CHECK-NEXT: <key>line</key><integer>364</integer>
// CHECK-NEXT: <key>col</key><integer>38</integer> // CHECK-NEXT: <key>col</key><integer>38</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer> // CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key> // CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key> // CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string> // CHECK-NEXT: <key>description</key><string>Conversion from value of type &apos;NSNumber *&apos; to incompatible type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string> // CHECK-NEXT: <key>category</key><string>Core Foundation/Objective-C</string>
// CHECK-NEXT: <key>type</key><string>Generics</string> // CHECK-NEXT: <key>type</key><string>Generics</string>
// CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string> // CHECK-NEXT: <key>check_name</key><string>core.DynamicTypePropagation</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>6528db66f562ac0c2a94933f3ca5f6a8</string> // CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>6528db66f562ac0c2a94933f3ca5f6a8</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string> // CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>testGetMostInformativeDerivedForId</string> // CHECK-NEXT: <key>issue_context</key><string>testGetMostInformativeDerivedForId</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>7</string> // CHECK-NEXT: <key>issue_hash_function_offset</key><string>7</string>
// CHECK-NEXT: <key>location</key> // CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict> // CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>343</integer> // CHECK-NEXT: <key>line</key><integer>364</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>path</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>373</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer> // CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer> // CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>373</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>control</string>
// CHECK-NEXT: <key>edges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>start</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>9</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>end</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>70</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>79</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>kind</key><string>event</string>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>70</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>ranges</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>70</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>79</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>depth</key><integer>0</integer>
// CHECK-NEXT: <key>extended_message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>message</key>
// CHECK-NEXT: <string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Object has a dynamic type &apos;NSNumber *&apos; which is incompatible with static type &apos;NSString *&apos;</string>
// CHECK-NEXT: <key>category</key><string>Type Error</string>
// CHECK-NEXT: <key>type</key><string>Dynamic and static type mismatch</string>
// CHECK-NEXT: <key>check_name</key><string>alpha.core.DynamicTypeChecker</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>56326e7b73d049256717eba7005ccc4d</string>
// CHECK-NEXT: <key>issue_context_kind</key><string>function</string>
// CHECK-NEXT: <key>issue_context</key><string>testArgumentAfterUpcastWithCovariantTypeParameter</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>3</string>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>375</integer>
// CHECK-NEXT: <key>col</key><integer>70</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>

test/Analysis/temp-obj-dtors-cfg-output.cpp

Show First 20 Lines • Show All 1,087 Lines • ▼ Show 20 Lines
// CHECK: [B1] // CHECK: [B1]
// CHECK: 1: int b; // CHECK: 1: int b;
// CHECK: Preds (1): B2(Unreachable) // CHECK: Preds (1): B2(Unreachable)
// CHECK: Succs (1): B0 // CHECK: Succs (1): B0
// CHECK: [B2 (NORETURN)] // CHECK: [B2 (NORETURN)]
// CHECK: 1: int a; // CHECK: 1: int a;
// CHECK: 2: NoReturn() (CXXConstructExpr, class NoReturn) // CHECK: 2: NoReturn() (CXXConstructExpr, class NoReturn)
// CHECK: 3: [B2.2] (BindTemporary) // CHECK: 3: [B2.2] (BindTemporary)
// CHECK: 4: [B2.3].f // CHECK: [[MEMBER:[45]]]: [B2.{{[34]}}].f
// CHECK: 5: [B2.4]() // CHECK: {{[56]}}: [B2.[[MEMBER]]]()
// CHECK: 6: ~NoReturn() (Temporary object destructor) // CHECK: {{[67]}}: ~NoReturn() (Temporary object destructor)
// CHECK: Preds (1): B3 // CHECK: Preds (1): B3
// CHECK: Succs (1): B0 // CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)] // CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2 // CHECK: Preds (2): B1 B2
// CHECK: [B3 (ENTRY)] // CHECK: [B3 (ENTRY)]
// CHECK: Succs (1): B2 // CHECK: Succs (1): B2
// CHECK: [B1] // CHECK: [B1]
// CHECK: 1: int b; // CHECK: 1: int b;
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

test/CXX/dcl.decl/dcl.init/dcl.init.aggr/p1.cpp

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Linesstruct DefaultedAggr {
DefaultedAggr() = default; DefaultedAggr() = default;
DefaultedAggr(const DefaultedAggr &) = default; DefaultedAggr(const DefaultedAggr &) = default;
DefaultedAggr(DefaultedAggr &&) = default; DefaultedAggr(DefaultedAggr &&) = default;
DefaultedAggr &operator=(const DefaultedAggr &) = default; DefaultedAggr &operator=(const DefaultedAggr &) = default;
DefaultedAggr &operator=(DefaultedAggr &&) = default; DefaultedAggr &operator=(DefaultedAggr &&) = default;
~DefaultedAggr() = default; ~DefaultedAggr() = default;
}; };
DefaultedAggr da = { 42 } ; DefaultedAggr da = { 42 } ;
struct ExplicitDefaultedAggr {
int n;
explicit ExplicitDefaultedAggr() = default; // expected-note {{candidate}}
ExplicitDefaultedAggr(const ExplicitDefaultedAggr &) = default; // expected-note {{candidate}}
ExplicitDefaultedAggr(ExplicitDefaultedAggr &&) = default; // expected-note {{candidate}}
};
ExplicitDefaultedAggr eda = { 42 }; // expected-error {{no matching constructor}}
ExplicitDefaultedAggr eda2{};
struct DefaultedBase {
int n;
DefaultedBase() = default; // expected-note 0+ {{candidate}}
DefaultedBase(DefaultedBase const&) = default; // expected-note 0+ {{candidate}}
DefaultedBase(DefaultedBase &&) = default; // expected-note 0+ {{candidate}}
};
struct InheritingConstructors : DefaultedBase { // expected-note 3 {{candidate}}
using DefaultedBase::DefaultedBase; // expected-note 2 {{inherited here}}
};
InheritingConstructors ic = { 42 }; // expected-error {{no matching constructor}}
struct NonInheritingConstructors : DefaultedBase {}; // expected-note 0+ {{candidate}}
NonInheritingConstructors nic = { 42 };
#if __cplusplus <= 201402L
// expected-error@-2 {{no matching constructor}}
#endif
struct NonAggrBase {
NonAggrBase(int) {}
};
struct HasNonAggrBase : NonAggrBase {}; // expected-note 0+ {{candidate}}
HasNonAggrBase hnab = {42};
#if __cplusplus <= 201402L
// expected-error@-2 {{no matching constructor}}
#endif

test/CXX/dcl.decl/dcl.init/p7.cpp

// RUN: %clang_cc1 -std=c++11 -verify %s // RUN: %clang_cc1 -std=c++11 -verify %s
struct NotAggregateBase {}; struct NotAggregateBase {};
struct A : NotAggregateBase { struct A : NotAggregateBase {
private: private:
A() = default; // expected-note {{here}} A() = default; // expected-note {{here}}
}; };
A a = {}; // expected-error {{calling a private constructor}} A a = {}; // expected-error {{calling a private constructor}}
struct B : NotAggregateBase { struct B : NotAggregateBase {
explicit B() = default; // expected-note {{here}} explicit B() = default; // expected-note {{here}}
}; };
B b = {}; // expected-error {{chosen constructor is explicit}} B b = {}; // expected-error {{chosen constructor is explicit}}
B b2{};
B b3;

test/CXX/drs/dr12xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// expected-no-diagnostics // expected-no-diagnostics
namespace dr1213 { // dr1213: 4.0
#if __cplusplus >= 201103L
using T = int[3];
int &&r = T{}[1];
using T = decltype((T{}));
using U = decltype((T{}[2]));
using U = int &&;
#endif
}
namespace dr1250 { // dr1250: 3.9 namespace dr1250 { // dr1250: 3.9
struct Incomplete; struct Incomplete;
struct Base { struct Base {
virtual const Incomplete *meow() = 0; virtual const Incomplete *meow() = 0;
}; };
struct Derived : Base { struct Derived : Base {
virtual Incomplete *meow(); virtual Incomplete *meow();
}; };
} // dr1250 } // dr1250

test/CXX/drs/dr15xx.cpp

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines#if __cplusplus >= 201103L
void(Wrap<nullptr_t>() < Wrap<int*>()); void(Wrap<nullptr_t>() < Wrap<int*>());
void(Wrap<nullptr_t>() > Wrap<int*>()); void(Wrap<nullptr_t>() > Wrap<int*>());
void(Wrap<nullptr_t>() <= Wrap<int*>()); void(Wrap<nullptr_t>() <= Wrap<int*>());
void(Wrap<nullptr_t>() >= Wrap<int*>()); void(Wrap<nullptr_t>() >= Wrap<int*>());
#endif #endif
} }
} }
namespace dr1518 { // dr1518: 4.0
#if __cplusplus >= 201103L
struct Z0 { // expected-note 0+ {{candidate}}
explicit Z0() = default; // expected-note 0+ {{here}}
};
struct Z { // expected-note 0+ {{candidate}}
explicit Z(); // expected-note 0+ {{here}}
explicit Z(int);
explicit Z(int, int); // expected-note 0+ {{here}}
};
template <class T> int Eat(T); // expected-note 0+ {{candidate}}
Z0 a;
Z0 b{};
Z0 c = {}; // expected-error {{explicit in copy-initialization}}
int i = Eat<Z0>({}); // expected-error {{no matching function for call to 'Eat'}}
Z c2 = {}; // expected-error {{explicit in copy-initialization}}
int i2 = Eat<Z>({}); // expected-error {{no matching function for call to 'Eat'}}
Z a1 = 1; // expected-error {{no viable conversion}}
Z a3 = Z(1);
Z a2(1);
Z *p = new Z(1);
Z a4 = (Z)1;
Z a5 = static_cast<Z>(1);
Z a6 = {4, 3}; // expected-error {{explicit in copy-initialization}}
struct UserProvidedBaseCtor { // expected-note 0+ {{candidate}}
UserProvidedBaseCtor() {}
};
struct DoesntInheritCtor : UserProvidedBaseCtor { // expected-note 0+ {{candidate}}
int x;
};
DoesntInheritCtor I{{}, 42};
#if __cplusplus <= 201402L
// expected-error@-2 {{no matching constructor}}
#endif
struct BaseCtor { BaseCtor() = default; }; // expected-note 0+ {{candidate}}
struct InheritsCtor : BaseCtor { // expected-note 1+ {{candidate}}
using BaseCtor::BaseCtor; // expected-note 2 {{inherited here}}
int x;
};
InheritsCtor II = {{}, 42}; // expected-error {{no matching constructor}}
#endif // __cplusplus >= 201103L
}
namespace dr1550 { // dr1550: yes namespace dr1550 { // dr1550: yes
int f(bool b, int n) { int f(bool b, int n) {
return (b ? (throw 0) : n) + (b ? n : (throw 0)); return (b ? (throw 0) : n) + (b ? n : (throw 0));
} }
} }
namespace dr1560 { // dr1560: 3.5 namespace dr1560 { // dr1560: 3.5
void f(bool b, int n) { void f(bool b, int n) {
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

test/CXX/drs/dr4xx.cpp

Show First 20 Lines • Show All 321 Lines • ▼ Show 20 Lines void test4(int *p, ptr<int> q) {
p->A::template id<int>::~id<int>(); p->A::template id<int>::~id<int>();
q->A::template id<int>::~id<int>(); q->A::template id<int>::~id<int>();
} }
#endif #endif
} }
namespace dr421 { // dr421: yes namespace dr421 { // dr421: yes
struct X { X(); int n; int &r; }; struct X { X(); int n; int &r; };
int *p = &X().n; // expected-error {{taking the address of a temporary}} int *p = &X().n; // expected-error-re {{{{taking the address of a temporary|cannot take the address of an rvalue}}}}
int *q = &X().r; int *q = &X().r;
} }
namespace dr422 { // dr422: yes namespace dr422 { // dr422: yes
template<typename T, typename U> void f() { template<typename T, typename U> void f() {
typedef T type; // expected-note {{prev}} typedef T type; // expected-note {{prev}}
typedef U type; // expected-error {{redef}} typedef U type; // expected-error {{redef}}
} }
▲ Show 20 Lines • Show All 886 Lines • Show Last 20 Lines

test/CXX/drs/dr6xx.cpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines
int dr614_a[(-1) / 2 == 0 ? 1 : -1]; // dr614: yes int dr614_a[(-1) / 2 == 0 ? 1 : -1]; // dr614: yes
int dr614_b[(-1) % 2 == -1 ? 1 : -1]; int dr614_b[(-1) % 2 == -1 ? 1 : -1];
namespace dr615 { // dr615: yes namespace dr615 { // dr615: yes
int f(); int f();
static int n = f(); static int n = f();
} }
namespace dr616 { // dr616: no namespace dr616 { // dr616: 4.0
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
struct S { int n; } s; struct S { int n; } s;
// FIXME: These should all be 'int &&' S f();
using T = decltype(S().n); using T = decltype((S().n));
using T = decltype(static_cast<S&&>(s).n); using T = decltype((static_cast<S&&>(s).n));
using T = decltype(S().*&S::n); // expected-note 2{{previous}} using T = decltype((f().n));
using T = decltype(static_cast<S&&>(s).*&S::n); // expected-error {{different type}} using T = decltype(S().*&S::n);
using T = int&&; // expected-error {{different type}} using T = decltype(static_cast<S&&>(s).*&S::n);
using T = decltype(f().*&S::n);
using T = int&&;
using U = decltype(S().n);
using U = decltype(static_cast<S&&>(s).n);
using U = int;
#endif #endif
} }
namespace dr618 { // dr618: yes namespace dr618 { // dr618: yes
#if (unsigned)-1 > 0 #if (unsigned)-1 > 0
#error wrong #error wrong
#endif #endif
} }
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

test/CXX/expr/expr.const/p2-0x.cpp

Show All 27 Linesstruct NonConstexpr2 {
constexpr NonConstexpr2(); // expected-note {{here}} constexpr NonConstexpr2(); // expected-note {{here}}
int n; int n;
}; };
struct NonConstexpr3 { struct NonConstexpr3 {
NonConstexpr3(); NonConstexpr3();
int m : NonConstexpr2().n; // expected-error {{constant expression}} expected-note {{undefined constructor 'NonConstexpr2'}} int m : NonConstexpr2().n; // expected-error {{constant expression}} expected-note {{undefined constructor 'NonConstexpr2'}}
}; };
struct NonConstexpr4 { struct NonConstexpr4 {
NonConstexpr4(); // expected-note {{declared here}} NonConstexpr4();
int n; int n;
}; };
struct NonConstexpr5 { struct NonConstexpr5 {
int n : NonConstexpr4().n; // expected-error {{constant expression}} expected-note {{non-constexpr constructor 'NonConstexpr4' cannot be used in a constant expression}} int n : NonConstexpr4().n; // expected-error {{constant expression}} expected-note {{non-literal type 'NonConstexpr4' cannot be used in a constant expression}}
}; };
// - an invocation of an undefined constexpr function or an undefined // - an invocation of an undefined constexpr function or an undefined
// constexpr constructor; // constexpr constructor;
struct UndefinedConstexpr { struct UndefinedConstexpr {
constexpr UndefinedConstexpr(); constexpr UndefinedConstexpr();
static constexpr int undefinedConstexpr1(); // expected-note {{here}} static constexpr int undefinedConstexpr1(); // expected-note {{here}}
int undefinedConstexpr2 : undefinedConstexpr1(); // expected-error {{constant expression}} expected-note {{undefined function 'undefinedConstexpr1' cannot be used in a constant expression}} int undefinedConstexpr2 : undefinedConstexpr1(); // expected-error {{constant expression}} expected-note {{undefined function 'undefinedConstexpr1' cannot be used in a constant expression}}
▲ Show 20 Lines • Show All 267 Lines • ▼ Show 20 Linesnamespace LValueToRValue {
static_assert(vs.i, ""); // expected-error {{constant expression}} expected-note {{read of volatile-qualified type}} static_assert(vs.i, ""); // expected-error {{constant expression}} expected-note {{read of volatile-qualified type}}
static_assert(const_cast<int&>(vs.i), ""); // expected-error {{constant expression}} expected-note {{read of volatile object 'vs'}} static_assert(const_cast<int&>(vs.i), ""); // expected-error {{constant expression}} expected-note {{read of volatile object 'vs'}}
static_assert(vrs.i, ""); // expected-error {{constant expression}} expected-note {{read of volatile-qualified type}} static_assert(vrs.i, ""); // expected-error {{constant expression}} expected-note {{read of volatile-qualified type}}
// - a non-volatile glvalue of literal type that refers to a non-volatile // - a non-volatile glvalue of literal type that refers to a non-volatile
// temporary object whose lifetime has not ended, initialized with a // temporary object whose lifetime has not ended, initialized with a
// constant expression; // constant expression;
constexpr volatile S f() { return S(); } constexpr volatile S f() { return S(); }
static_assert(f().i, ""); // ok! there's no lvalue-to-rvalue conversion here! static_assert(f().i, ""); // expected-error {{constant expression}} expected-note {{read of volatile-qualified type}}
static_assert(((volatile const S&&)(S)0).i, ""); // expected-error {{constant expression}} expected-note {{read of volatile-qualified type}} static_assert(((volatile const S&&)(S)0).i, ""); // expected-error {{constant expression}} expected-note {{read of volatile-qualified type}}
} }
// DR1312: The proposed wording for this defect has issues, so we ignore this // DR1312: The proposed wording for this defect has issues, so we ignore this
// bullet and instead prohibit casts from pointers to cv void (see core-20842 // bullet and instead prohibit casts from pointers to cv void (see core-20842
// and core-20845). // and core-20845).
// //
// - an lvalue-to-rvalue conversion (4.1 [conv.lval]) that is applied to a // - an lvalue-to-rvalue conversion (4.1 [conv.lval]) that is applied to a
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines

test/CodeGenCXX/builtins-arm-exclusive.cpp

  • This file was added.
// RUN: %clang_cc1 -Wall -Werror -triple thumbv8-linux-gnueabi -fno-signed-char -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -Wall -Werror -triple arm64-apple-ios7.0 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-ARM64
bool b;
// CHECK-LABEL: @_Z10test_ldrexv()
// CHECK: call i32 @llvm.arm.ldrex.p0i8(i8* @b)
// CHECK-ARM64-LABEL: @_Z10test_ldrexv()
// CHECK-ARM64: call i64 @llvm.aarch64.ldxr.p0i8(i8* @b)
void test_ldrex() {
b = __builtin_arm_ldrex(&b);
}
// CHECK-LABEL: @_Z10tset_strexv()
// CHECK: %{{.*}} = call i32 @llvm.arm.strex.p0i8(i32 1, i8* @b)
// CHECK-ARM64-LABEL: @_Z10tset_strexv()
// CHECK-ARM64: %{{.*}} = call i32 @llvm.aarch64.stxr.p0i8(i64 1, i8* @b)
void tset_strex() {
__builtin_arm_strex(true, &b);
}

test/CodeGenCXX/compound-literals.cpp

// RUN: %clang_cc1 -std=c++11 -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -std=c++11 -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s
struct X { struct X {
X(); X();
X(const X&); X(const X&);
X(const char*); X(const char*);
~X(); ~X();
}; };
struct Y { struct Y {
int i; int i;
X x; X x;
}; };
// CHECK: @.compoundliteral = internal global [5 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5], align 4
// CHECK: @q = global i32* getelementptr inbounds ([5 x i32], [5 x i32]* @.compoundliteral, i32 0, i32 0), align 4
// CHECK-LABEL: define i32 @_Z1fv() // CHECK-LABEL: define i32 @_Z1fv()
int f() { int f() {
// CHECK: [[LVALUE:%[a-z0-9.]+]] = alloca // CHECK: [[LVALUE:%[a-z0-9.]+]] = alloca
// CHECK-NEXT: [[I:%[a-z0-9]+]] = getelementptr inbounds {{.*}}, {{.*}}* [[LVALUE]], i32 0, i32 0 // CHECK-NEXT: [[I:%[a-z0-9]+]] = getelementptr inbounds {{.*}}, {{.*}}* [[LVALUE]], i32 0, i32 0
// CHECK-NEXT: store i32 17, i32* [[I]] // CHECK-NEXT: store i32 17, i32* [[I]]
// CHECK-NEXT: [[X:%[a-z0-9]+]] = getelementptr inbounds {{.*}} [[LVALUE]], i32 0, i32 1 // CHECK-NEXT: [[X:%[a-z0-9]+]] = getelementptr inbounds {{.*}} [[LVALUE]], i32 0, i32 1
// CHECK-NEXT: call %struct.X* @_ZN1XC1EPKc({{.*}}[[X]] // CHECK-NEXT: call %struct.X* @_ZN1XC1EPKc({{.*}}[[X]]
// CHECK-NEXT: [[I:%[a-z0-9]+]] = getelementptr inbounds {{.*}} [[LVALUE]], i32 0, i32 0 // CHECK-NEXT: [[I:%[a-z0-9]+]] = getelementptr inbounds {{.*}} [[LVALUE]], i32 0, i32 0
Show All 10 Linesint g() {
// CHECK: [[A:%[a-z0-9.]+]] = load [2 x i32]*, [2 x i32]** [[V]] // CHECK: [[A:%[a-z0-9.]+]] = load [2 x i32]*, [2 x i32]** [[V]]
// CHECK-NEXT: [[A0ADDR:%[a-z0-9.]+]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i32 0, {{.*}} 0 // CHECK-NEXT: [[A0ADDR:%[a-z0-9.]+]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i32 0, {{.*}} 0
// CHECK-NEXT: [[A0:%[a-z0-9.]+]] = load i32, i32* [[A0ADDR]] // CHECK-NEXT: [[A0:%[a-z0-9.]+]] = load i32, i32* [[A0ADDR]]
// CHECK-NEXT: ret i32 [[A0]] // CHECK-NEXT: ret i32 [[A0]]
return v[0]; return v[0];
} }
// GCC's compound-literals-in-C++ extension lifetime-extends a compound literal
// (or a C++11 list-initialized temporary!) if:
// - it is at global scope
// - it has array type
// - it has a constant initializer
struct Z { int i[3]; }; struct Z { int i[3]; };
int *p = (Z){ {1, 2, 3} }.i; int *p = (Z){ {1, 2, 3} }.i;
// CHECK: define {{.*}}__cxx_global_var_init() // CHECK: define {{.*}}__cxx_global_var_init()
// CHECK: store i32* getelementptr inbounds (%struct.Z, %struct.Z* @.compoundliteral, i32 0, i32 0, i32 0), i32** @p // CHECK: alloca %struct.Z
// CHECK: store i32* %{{.*}}, i32** @p
int *q = (int [5]){1, 2, 3, 4, 5};
// (constant initialization, checked above)
int *PR21912_1 = (int []){}; extern int n;
int *r = (int [5]){1, 2, 3, 4, 5} + n;
// CHECK-LABEL: define {{.*}}__cxx_global_var_init.1() // CHECK-LABEL: define {{.*}}__cxx_global_var_init.1()
// CHECK: store i32* getelementptr inbounds ([0 x i32], [0 x i32]* @.compoundliteral.2, i32 0, i32 0), i32** @PR21912_1 // CHECK: %[[PTR:.*]] = getelementptr inbounds i32, i32* getelementptr inbounds ([5 x i32], [5 x i32]* @.compoundliteral.2, i32 0, i32 0), i32 %
// CHECK: store i32* %[[PTR]], i32** @r
int *PR21912_1 = (int []){} + n;
// CHECK-LABEL: define {{.*}}__cxx_global_var_init.3()
// CHECK: %[[PTR:.*]] = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @.compoundliteral.4, i32 0, i32 0), i32 %
// CHECK: store i32* %[[PTR]], i32** @PR21912_1
union PR21912Ty { union PR21912Ty {
long long l; long long l;
double d; double d;
}; };
union PR21912Ty *PR21912_2 = (union PR21912Ty[]){{.d = 2.0}, {.l = 3}}; union PR21912Ty *PR21912_2 = (union PR21912Ty[]){{.d = 2.0}, {.l = 3}} + n;
// CHECK-LABEL: define {{.*}}__cxx_global_var_init.3() // CHECK-LABEL: define {{.*}}__cxx_global_var_init.5()
// CHECK: store %union.PR21912Ty* getelementptr inbounds ([2 x %union.PR21912Ty], [2 x %union.PR21912Ty]* bitcast (<{ { double }, %union.PR21912Ty }>* @.compoundliteral.4 to [2 x %union.PR21912Ty]*), i32 0, i32 0), %union.PR21912Ty** @PR21912_2 // CHECK: %[[PTR:.*]] = getelementptr inbounds %union.PR21912Ty, %union.PR21912Ty* getelementptr inbounds ([2 x %union.PR21912Ty], [2 x %union.PR21912Ty]* bitcast (<{ { double }, %union.PR21912Ty }>* @.compoundliteral.6 to [2 x %union.PR21912Ty]*), i32 0, i32 0), i32 %
// CHECK: store %union.PR21912Ty* %[[PTR]], %union.PR21912Ty** @PR21912_2, align 4
// This compound literal should have local scope. // This compound literal should have local scope.
int computed_with_lambda = [] { int computed_with_lambda = [] {
int *array = (int[]) { 1, 3, 5, 7 }; int *array = (int[]) { 1, 3, 5, 7 };
return array[0]; return array[0];
}(); }();
// CHECK-LABEL: define internal i32 @{{.*}}clEv // CHECK-LABEL: define internal i32 @{{.*}}clEv
// CHECK: alloca [4 x i32] // CHECK: alloca [4 x i32]

test/CodeGenCXX/dllexport.cpp

Show First 20 Lines • Show All 765 Lines • ▼ Show 20 Lines
template <typename T> struct ExplicitInstantiationDeclExportedDefTemplate { void f() {} ExplicitInstantiationDeclExportedDefTemplate() {} }; template <typename T> struct ExplicitInstantiationDeclExportedDefTemplate { void f() {} ExplicitInstantiationDeclExportedDefTemplate() {} };
extern template struct ExplicitInstantiationDeclExportedDefTemplate<int>; extern template struct ExplicitInstantiationDeclExportedDefTemplate<int>;
template struct __declspec(dllexport) ExplicitInstantiationDeclExportedDefTemplate<int>; template struct __declspec(dllexport) ExplicitInstantiationDeclExportedDefTemplate<int>;
USEMEMFUNC(ExplicitInstantiationDeclExportedDefTemplate<int>, f); USEMEMFUNC(ExplicitInstantiationDeclExportedDefTemplate<int>, f);
// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?f@?$ExplicitInstantiationDeclExportedDefTemplate@H@@QAEXXZ" // M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?f@?$ExplicitInstantiationDeclExportedDefTemplate@H@@QAEXXZ"
// M32-DAG: define weak_odr dllexport x86_thiscallcc %struct.ExplicitInstantiationDeclExportedDefTemplate* @"\01??0?$ExplicitInstantiationDeclExportedDefTemplate@H@@QAE@XZ" // M32-DAG: define weak_odr dllexport x86_thiscallcc %struct.ExplicitInstantiationDeclExportedDefTemplate* @"\01??0?$ExplicitInstantiationDeclExportedDefTemplate@H@@QAE@XZ"
// G32-DAG: define weak_odr x86_thiscallcc void @_ZN44ExplicitInstantiationDeclExportedDefTemplateIiE1fEv // G32-DAG: define weak_odr x86_thiscallcc void @_ZN44ExplicitInstantiationDeclExportedDefTemplateIiE1fEv
template <typename T> struct ImplicitInstantiationExplicitInstantiationDefExportedTemplate { void f() {} };
ImplicitInstantiationExplicitInstantiationDefExportedTemplate<int> ImplicitInstantiationExplicitInstantiationDefExportedTemplateInstance;
template class __declspec(dllexport) ImplicitInstantiationExplicitInstantiationDefExportedTemplate<int>;
USEMEMFUNC(ImplicitInstantiationExplicitInstantiationDefExportedTemplate<int>, f);
// M32-DAG: define weak_odr dllexport x86_thiscallcc void @"\01?f@?$ImplicitInstantiationExplicitInstantiationDefExportedTemplate@H@@QAEXXZ"
// G32-DAG: define weak_odr x86_thiscallcc void @_ZN61ImplicitInstantiationExplicitInstantiationDefExportedTemplateIiE1fEv
namespace { struct InternalLinkageType {}; } namespace { struct InternalLinkageType {}; }
struct __declspec(dllexport) PR23308 { struct __declspec(dllexport) PR23308 {
void f(InternalLinkageType*); void f(InternalLinkageType*);
}; };
void PR23308::f(InternalLinkageType*) {} void PR23308::f(InternalLinkageType*) {}
long use(PR23308* p) { p->f(nullptr); } long use(PR23308* p) { p->f(nullptr); }
// M32-DAG: define internal x86_thiscallcc void @"\01?f@PR23308@@QAEXPAUInternalLinkageType@?A@@@Z" // M32-DAG: define internal x86_thiscallcc void @"\01?f@PR23308@@QAEXPAUInternalLinkageType@?A@@@Z"
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

test/CodeGenCXX/enable_if.cpp

// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-pc-linux-gnu| FileCheck %s // RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-pc-linux-gnu | FileCheck %s
// Test address-of overloading logic // Test address-of overloading logic
int test5(int); int test5(int);
template <typename T> template <typename T>
T test5(T) __attribute__((enable_if(1, "better than non-template"))); T test5(T) __attribute__((enable_if(1, "better than non-template")));
// CHECK: @_Z5test5IiEUa9enable_ifIXLi1EEET_S0_ // CHECK: @_Z5test5IiEUa9enable_ifIXLi1EEET_S0_
int (*Ptr)(int) = &test5; int (*Ptr)(int) = &test5;
Show All 20 Lines

test/CodeGenCXX/stack-reuse.cpp

Show First 20 Lines • Show All 126 Lines • ▼ Show 20 Lines// CHECK: call void @llvm.lifetime.end
{ {
S_large s; S_large s;
bar_large(&s); bar_large(&s);
} }
} }
int large_combiner_test(S_large s) { int large_combiner_test(S_large s) {
// CHECK-LABEL: define i32 @large_combiner_test // CHECK-LABEL: define i32 @large_combiner_test
// CHECK: [[T1:%.*]] = alloca %struct.Combiner
// CHECK: [[T2:%.*]] = alloca %struct.Combiner // CHECK: [[T2:%.*]] = alloca %struct.Combiner
// CHECK: [[T1:%.*]] = alloca %struct.Combiner
// CHECK: [[T3:%.*]] = call %struct.Combiner* @_ZN8CombinerC1E7S_large(%struct.Combiner* nonnull [[T1]], [9 x i32] %s.coerce) // CHECK: [[T3:%.*]] = call %struct.Combiner* @_ZN8CombinerC1E7S_large(%struct.Combiner* nonnull [[T1]], [9 x i32] %s.coerce)
// CHECK: call void @_ZN8Combiner1fEv(%struct.Combiner* nonnull sret [[T2]], %struct.Combiner* nonnull [[T1]]) // CHECK: call void @_ZN8Combiner1fEv(%struct.Combiner* nonnull sret [[T2]], %struct.Combiner* nonnull [[T1]])
// CHECK: [[T4:%.*]] = getelementptr inbounds %struct.Combiner, %struct.Combiner* [[T2]], i32 0, i32 0, i32 0, i32 0 // CHECK: [[T4:%.*]] = getelementptr inbounds %struct.Combiner, %struct.Combiner* [[T2]], i32 0, i32 0, i32 0, i32 0
// CHECK: [[T5:%.*]] = load i32, i32* [[T4]] // CHECK: [[T5:%.*]] = load i32, i32* [[T4]]
// CHECK: ret i32 [[T5]] // CHECK: ret i32 [[T5]]
return Combiner(s).f().a.a[0]; return Combiner(s).f().a.a[0];
} }
} }

test/CodeGenCXX/temporaries.cpp

Show First 20 Lines • Show All 773 Lines • ▼ Show 20 Lines void f() {
// CHECK: call void @[[NS]]1DD1Ev({{.*}} %[[TEMPD2]]) // CHECK: call void @[[NS]]1DD1Ev({{.*}} %[[TEMPD2]])
// CHECK: call void @[[NS]]1AD1Ev({{.*}} %[[TEMPA2]]) // CHECK: call void @[[NS]]1AD1Ev({{.*}} %[[TEMPA2]])
// CHECK: call void @[[NS]]1ED1Ev({{.*}} %[[TEMPE1]]) // CHECK: call void @[[NS]]1ED1Ev({{.*}} %[[TEMPE1]])
// CHECK: call void @[[NS]]1DD1Ev({{.*}} %[[TEMPD1]]) // CHECK: call void @[[NS]]1DD1Ev({{.*}} %[[TEMPD1]])
// CHECK: call void @[[NS]]1AD1Ev({{.*}} %[[TEMPA1]]) // CHECK: call void @[[NS]]1AD1Ev({{.*}} %[[TEMPA1]])
} }
} }
namespace ArrayAccess {
struct A { A(int); ~A(); };
void g();
void f() {
using T = A[3];
// CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 1
// CHECK-NOT: @_ZN11ArrayAccess1AD
// CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 2
// CHECK-NOT: @_ZN11ArrayAccess1AD
// CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 3
// CHECK-NOT: @_ZN11ArrayAccess1AD
A &&a = T{1, 2, 3}[1];
// CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 4
// CHECK-NOT: @_ZN11ArrayAccess1AD
// CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 5
// CHECK-NOT: @_ZN11ArrayAccess1AD
// CHECK: call void @_ZN11ArrayAccess1AC1Ei({{.*}}, i32 6
// CHECK-NOT: @_ZN11ArrayAccess1AD
A &&b = 2[T{4, 5, 6}];
// CHECK: call void @_ZN11ArrayAccess1gEv(
g();
// CHECK: call void @_ZN11ArrayAccess1AD
// CHECK: call void @_ZN11ArrayAccess1AD
}
}
namespace PR14130 { namespace PR14130 {
struct S { S(int); }; struct S { S(int); };
struct U { S &&s; }; struct U { S &&s; };
U v { { 0 } }; U v { { 0 } };
// CHECK: call void @_ZN7PR141301SC1Ei({{.*}} @_ZGRN7PR141301vE_, i32 0) // CHECK: call void @_ZN7PR141301SC1Ei({{.*}} @_ZGRN7PR141301vE_, i32 0)
// CHECK: store {{.*}} @_ZGRN7PR141301vE_, {{.*}} @_ZN7PR141301vE // CHECK: store {{.*}} @_ZGRN7PR141301vE_, {{.*}} @_ZN7PR141301vE
} }
Show All 12 Lines

test/CodeGenCXX/windows-implicit-dllexport-template-specialization.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++11 -triple i686-windows -fdeclspec -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-MS
// RUN: %clang_cc1 -std=c++11 -triple i686-windows-itanium -fdeclspec -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-IA
template <typename>
struct s {};
template <typename T_>
class t : s<T_> {};
extern template class t<char>;
template class __declspec(dllexport) t<char>;
// CHECK-MS: dllexport {{.*}} @"\01??4?$t@D@@QAEAAV0@ABV0@@Z"
// CHECK-MS: dllexport {{.*}} @"\01??4?$s@D@@QAEAAU0@ABU0@@Z"
// CHECK-IA: dllexport {{.*}} @_ZN1tIcEaSERKS0_
// CHECK-IA: dllexport {{.*}} @_ZN1sIcEaSERKS0_

test/CodeGenCXX/windows-itanium-dllexport.cpp

Show All 17 Lines
// CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIiE1fEv // CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIiE1fEv
extern template class c<char>; extern template class c<char>;
template class __declspec(dllexport) c<char>; template class __declspec(dllexport) c<char>;
// CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIcEaSERKS0_ // CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIcEaSERKS0_
// CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIcE1fEv // CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIcE1fEv
c<double> g;
template class __declspec(dllexport) c<double>;
// CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIdEaSERKS0_
// CHECK: define {{.*}} dllexport {{.*}} @_ZN1cIdE1fEv

test/CodeGenCXX/windows-itanium-type-info.cpp

// RUN: %clang_cc1 -triple i686-windows-itanium -fdeclspec -emit-llvm %s -o - | FileCheck %s // RUN: %clang_cc1 -triple i686-windows-itanium -fdeclspec -emit-llvm %s -o - | FileCheck %s
namespace __cxxabiv1 { namespace __cxxabiv1 {
class __declspec(dllexport) __fundamental_type_info { class __declspec(dllexport) __fundamental_type_info {
public: public:
virtual ~__fundamental_type_info(); virtual ~__fundamental_type_info();
}; };
__fundamental_type_info::~__fundamental_type_info() {} __fundamental_type_info::~__fundamental_type_info() {}
} }
// CHECK: @_ZTIi = dllexport constant struct __declspec(dllimport) base {
virtual void method();
};
struct __declspec(dllexport) derived : base {
virtual ~derived();
};
derived::~derived() {
method();
}
// CHECK-DAG: @_ZTIi = dllexport constant
// CHECK-DAG: @_ZTSi = dllexport constant
// CHECK-DAG: @_ZTI7derived = dllexport constant
// CHECK-DAG: @_ZTS7derived = dllexport constant
// CHECK-DAG: @_ZTV7derived = dllexport unnamed_addr constant
// CHECK-DAG: @_ZTI4base = external dllimport constant
// CHECK-DAG: @_ZTS4base = external dllimport constant
// CHECK-NOT: @_ZTV4base = external dllimport constant

test/Driver/cuda-no-sanitizers.cu

// Check that -fsanitize=foo doesn't get passed down to device-side // Check that -fsanitize=foo doesn't get passed down to device-side
// compilation. // compilation.
// //
// REQUIRES: clang-driver // REQUIRES: clang-driver
// //
// RUN: %clang -### -target x86_64-linux-gnu -c --cuda-gpu-arch=sm_20 -fsanitize=address %s 2>&1 | \ // RUN: %clang -### -target x86_64-linux-gnu -c --cuda-gpu-arch=sm_20 -fsanitize=address %s 2>&1 | \
// RUN: FileCheck %s // RUN: FileCheck %s
// CHECK-NOT: error: unsupported option '-fsanitize=address'
// CHECK-DAG: "-fcuda-is-device" // CHECK-DAG: "-fcuda-is-device"
// CHECK-NOT: "-fsanitize=address" // CHECK-NOT: "-fsanitize=address"
// CHECK-DAG: "-triple" "x86_64--linux-gnu" // CHECK-DAG: "-triple" "x86_64--linux-gnu"
// CHECK: "-fsanitize=address" // CHECK: "-fsanitize=address"

test/Driver/darwin-ld.c

Show First 20 Lines • Show All 326 Lines • ▼ Show 20 Lines
// LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1.2.6' // LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1.2.6'
// LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1.a' // LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1.a'
// LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1a' // LINK_VERSION_DIGITS: invalid version number in '-mlinker-version=133.3.0.1a'
// Check that we're passing -lto-pass-remarks-output for LTO // Check that we're passing -lto-pass-remarks-output for LTO
// RUN: %clang -target x86_64-apple-darwin12 %t.o -fsave-optimization-record -### -o foo/bar.out 2> %t.log // RUN: %clang -target x86_64-apple-darwin12 %t.o -fsave-optimization-record -### -o foo/bar.out 2> %t.log
// RUN: FileCheck -check-prefix=PASS_REMARKS_OUTPUT %s < %t.log // RUN: FileCheck -check-prefix=PASS_REMARKS_OUTPUT %s < %t.log
// PASS_REMARKS_OUTPUT: "-mllvm" "-lto-pass-remarks-output" "-mllvm" "foo/bar.out.opt.yaml" // PASS_REMARKS_OUTPUT: "-mllvm" "-lto-pass-remarks-output" "-mllvm" "foo/bar.out.opt.yaml"
// PASS_REMARKS_OUTPUT-NOT: -lto-pass-remarks-with-hotness
// RUN: %clang -target x86_64-apple-darwin12 %t.o -fsave-optimization-record -### 2> %t.log // RUN: %clang -target x86_64-apple-darwin12 %t.o -fsave-optimization-record -### 2> %t.log
// RUN: FileCheck -check-prefix=PASS_REMARKS_OUTPUT_NO_O %s < %t.log // RUN: FileCheck -check-prefix=PASS_REMARKS_OUTPUT_NO_O %s < %t.log
// PASS_REMARKS_OUTPUT_NO_O: "-mllvm" "-lto-pass-remarks-output" "-mllvm" "a.out.opt.yaml" // PASS_REMARKS_OUTPUT_NO_O: "-mllvm" "-lto-pass-remarks-output" "-mllvm" "a.out.opt.yaml"
// RUN: %clang -target x86_64-apple-darwin12 %t.o -fsave-optimization-record -fprofile-instr-use=blah -### -o foo/bar.out 2> %t.log
// RUN: FileCheck -check-prefix=PASS_REMARKS_WITH_HOTNESS %s < %t.log
// PASS_REMARKS_WITH_HOTNESS: "-mllvm" "-lto-pass-remarks-output" "-mllvm" "foo/bar.out.opt.yaml" "-mllvm" "-lto-pass-remarks-with-hotness"

test/Driver/defsym.s

  • This file was added.
// RUN: %clang -### -c -integrated-as %s \
// RUN: -Wa,-defsym,abc=5 -Wa,-defsym,xyz=0xa \
// RUN: 2>&1 | FileCheck %s --check-prefix=CHECK-DEFSYM1
// RUN: %clang -### -c -no-integrated-as -target x86_64-unknown-unknown %s \
// RUN: -Wa,-defsym,abc=5 -Wa,-defsym,xyz=0xa \
// RUN: 2>&1 | FileCheck %s --check-prefix=CHECK-DEFSYM1
// CHECK-DEFSYM1: "-defsym"
// CHECK-DEFSYM1: "abc=5"
// CHECK-DEFSYM1: "-defsym"
// CHECK-DEFSYM1: "xyz=0xa"
// RUN: not %clang -c -integrated-as -o /dev/null %s \
// RUN: -Wa,-defsym,abc= \
// RUN: 2>&1 | FileCheck %s --check-prefix=CHECK-DEFSYM-ERR1
// CHECK-DEFSYM-ERR1: error: defsym must be of the form: sym=value: abc=
// RUN: not %clang -c -integrated-as -o /dev/null %s \
// RUN: -Wa,-defsym,abc=1a2b3c \
// RUN: 2>&1 | FileCheck %s --check-prefix=CHECK-DEFSYM-ERR2
// CHECK-DEFSYM-ERR2: error: Value is not an integer: 1a2b3c

test/Frontend/include-duplicate-removal.c

  • This file was added.
// RUN: %clang_cc1 -v -I%S/Inputs -iquote %S/Inputs/SystemHeaderPrefix -isystem %S/Inputs/SystemHeaderPrefix -isystem %S/Inputs/SystemHeaderPrefix %s 2>&1 | FileCheck %s
#include <test.h>
// CHECK: ignoring duplicate directory
// CHECK-SAME: Inputs/SystemHeaderPrefix"{{$}}
// CHECK: #include "..."
// CHECK-NEXT: {{.*}}Inputs/SystemHeaderPrefix{{$}}
// CHECK-NEXT: #include <...>
// CHECK-NEXT: {{.*}}Inputs{{$}}
// CHECK-NEXT: {{.*}}Inputs/SystemHeaderPrefix{{$}}

test/Index/evaluate-cursor.cpp

Show All 9 Lines
#define FUNC_MAC(x) x #define FUNC_MAC(x) x
void goo() { void goo() {
int p = FUNC_MAC(1); int p = FUNC_MAC(1);
int a = __LINE__; int a = __LINE__;
} }
unsigned long long foo_int = 1ull << 60;
unsigned long long HUGE = 1ull << 63;
long long HUGE_NEG = -(1ll << 35);
// RUN: c-index-test -evaluate-cursor-at=%s:4:7 \ // RUN: c-index-test -evaluate-cursor-at=%s:4:7 \
// RUN: -evaluate-cursor-at=%s:8:7 \ // RUN: -evaluate-cursor-at=%s:8:7 \
// RUN: -evaluate-cursor-at=%s:8:11 -std=c++11 %s | FileCheck %s // RUN: -evaluate-cursor-at=%s:8:11 -std=c++11 %s | FileCheck %s
// CHECK: Value: 10 // CHECK: Value: 10
// CHECK: Value: 11 // CHECK: Value: 11
// CHECK: Value: 11 // CHECK: Value: 11
// RUN: c-index-test -get-macro-info-cursor-at=%s:11:9 \ // RUN: c-index-test -get-macro-info-cursor-at=%s:11:9 \
// RUN: -get-macro-info-cursor-at=%s:14:11 \ // RUN: -get-macro-info-cursor-at=%s:14:11 \
// RUN: -get-macro-info-cursor-at=%s:15:11 -std=c++11 %s | FileCheck -check-prefix=CHECK-MACRO %s // RUN: -get-macro-info-cursor-at=%s:15:11 -std=c++11 %s | FileCheck -check-prefix=CHECK-MACRO %s
// CHECK-MACRO: [function macro] // CHECK-MACRO: [function macro]
// CHECK-MACRO: [function macro] // CHECK-MACRO: [function macro]
// CHECK-MACRO: [builtin macro] // CHECK-MACRO: [builtin macro]
// RUN: c-index-test -evaluate-cursor-at=%s:18:20 \
// RUN: -evaluate-cursor-at=%s:20:20 \
// RUN: -evaluate-cursor-at=%s:22:11 \
// RUN: -std=c++11 %s | FileCheck -check-prefix=CHECK-LONG %s
// CHECK-LONG: unsigned, Value: 1152921504606846976
// CHECK-LONG: unsigned, Value: 9223372036854775808
// CHECK-LONG: Value: -34359738368

test/Lexer/cxx-features.cpp

Show All 28 Lines
#if check(inline_variables, 0, 0, 0, 201606) // FIXME: provisional name #if check(inline_variables, 0, 0, 0, 201606) // FIXME: provisional name
#error "wrong value for __cpp_inline_variables" #error "wrong value for __cpp_inline_variables"
#endif #endif
#if check(aligned_new, 0, 0, 0, 201606) // FIXME: provisional name #if check(aligned_new, 0, 0, 0, 201606) // FIXME: provisional name
#error "wrong value for __cpp_aligned_new" #error "wrong value for __cpp_aligned_new"
#endif #endif
#if check(noexcept_function_type, 0, 0, 0, 0) #if check(noexcept_function_type, 0, 0, 0, 201510)
// FIXME: value shuld be 201510 for cxx1z once implemented
#error "wrong value for __cpp_noexcept_function_type" #error "wrong value for __cpp_noexcept_function_type"
#endif #endif
#if check(fold_expressions, 0, 0, 0, 201603) #if check(fold_expressions, 0, 0, 0, 201603)
#error "wrong value for __cpp_fold_expressions" #error "wrong value for __cpp_fold_expressions"
#endif #endif
#if check(capture_star_this, 0, 0, 0, 201603) #if check(capture_star_this, 0, 0, 0, 201603)
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

test/Misc/warning-flags.c

Show All 12 Lines(2) It prevents us adding new warnings to Clang that have no -W flag. All
new warnings should have -W flags. new warnings should have -W flags.
If you add a new warning without a flag, this test will fail. To fix If you add a new warning without a flag, this test will fail. To fix
this test, simply add a warning group to that warning. this test, simply add a warning group to that warning.
The list of warnings below should NEVER grow. It should gradually shrink to 0. The list of warnings below should NEVER grow. It should gradually shrink to 0.
CHECK: Warnings without flags (82): CHECK: Warnings without flags (80):
CHECK-NEXT: ext_excess_initializers CHECK-NEXT: ext_excess_initializers
CHECK-NEXT: ext_excess_initializers_in_char_array_initializer CHECK-NEXT: ext_excess_initializers_in_char_array_initializer
CHECK-NEXT: ext_expected_semi_decl_list CHECK-NEXT: ext_expected_semi_decl_list
CHECK-NEXT: ext_explicit_specialization_storage_class CHECK-NEXT: ext_explicit_specialization_storage_class
CHECK-NEXT: ext_initializer_string_for_char_array_too_long CHECK-NEXT: ext_initializer_string_for_char_array_too_long
CHECK-NEXT: ext_missing_declspec CHECK-NEXT: ext_missing_declspec
CHECK-NEXT: ext_missing_whitespace_after_macro_name CHECK-NEXT: ext_missing_whitespace_after_macro_name
CHECK-NEXT: ext_new_paren_array_nonconst CHECK-NEXT: ext_new_paren_array_nonconst
CHECK-NEXT: ext_plain_complex CHECK-NEXT: ext_plain_complex
CHECK-NEXT: ext_template_arg_extra_parens CHECK-NEXT: ext_template_arg_extra_parens
CHECK-NEXT: ext_typecheck_comparison_of_pointer_integer CHECK-NEXT: ext_typecheck_comparison_of_pointer_integer
CHECK-NEXT: ext_typecheck_cond_incompatible_operands CHECK-NEXT: ext_typecheck_cond_incompatible_operands
CHECK-NEXT: ext_typecheck_ordered_comparison_of_function_pointers CHECK-NEXT: ext_typecheck_ordered_comparison_of_function_pointers
CHECK-NEXT: ext_typecheck_ordered_comparison_of_pointer_integer CHECK-NEXT: ext_typecheck_ordered_comparison_of_pointer_integer
CHECK-NEXT: ext_using_undefined_std CHECK-NEXT: ext_using_undefined_std
CHECK-NEXT: pp_invalid_string_literal CHECK-NEXT: pp_invalid_string_literal
CHECK-NEXT: pp_out_of_date_dependency CHECK-NEXT: pp_out_of_date_dependency
CHECK-NEXT: pp_poisoning_existing_macro CHECK-NEXT: pp_poisoning_existing_macro
CHECK-NEXT: w_asm_qualifier_ignored
CHECK-NEXT: warn_accessor_property_type_mismatch CHECK-NEXT: warn_accessor_property_type_mismatch
CHECK-NEXT: warn_arcmt_nsalloc_realloc CHECK-NEXT: warn_arcmt_nsalloc_realloc
CHECK-NEXT: warn_asm_label_on_auto_decl CHECK-NEXT: warn_asm_label_on_auto_decl
CHECK-NEXT: warn_c_kext CHECK-NEXT: warn_c_kext
CHECK-NEXT: warn_call_to_pure_virtual_member_function_from_ctor_dtor CHECK-NEXT: warn_call_to_pure_virtual_member_function_from_ctor_dtor
CHECK-NEXT: warn_call_wrong_number_of_arguments CHECK-NEXT: warn_call_wrong_number_of_arguments
CHECK-NEXT: warn_case_empty_range CHECK-NEXT: warn_case_empty_range
CHECK-NEXT: warn_char_constant_too_large CHECK-NEXT: warn_char_constant_too_large
Show All 10 Lines
CHECK-NEXT: warn_drv_pch_not_first_include CHECK-NEXT: warn_drv_pch_not_first_include
CHECK-NEXT: warn_dup_category_def CHECK-NEXT: warn_dup_category_def
CHECK-NEXT: warn_enum_value_overflow CHECK-NEXT: warn_enum_value_overflow
CHECK-NEXT: warn_expected_qualified_after_typename CHECK-NEXT: warn_expected_qualified_after_typename
CHECK-NEXT: warn_extraneous_char_constant CHECK-NEXT: warn_extraneous_char_constant
CHECK-NEXT: warn_fe_cc_log_diagnostics_failure CHECK-NEXT: warn_fe_cc_log_diagnostics_failure
CHECK-NEXT: warn_fe_cc_print_header_failure CHECK-NEXT: warn_fe_cc_print_header_failure
CHECK-NEXT: warn_fe_macro_contains_embedded_newline CHECK-NEXT: warn_fe_macro_contains_embedded_newline
CHECK-NEXT: warn_file_asm_volatile
CHECK-NEXT: warn_ignoring_ftabstop_value CHECK-NEXT: warn_ignoring_ftabstop_value
CHECK-NEXT: warn_implements_nscopying CHECK-NEXT: warn_implements_nscopying
CHECK-NEXT: warn_incompatible_qualified_id CHECK-NEXT: warn_incompatible_qualified_id
CHECK-NEXT: warn_inline_namespace_reopened_noninline CHECK-NEXT: warn_inline_namespace_reopened_noninline
CHECK-NEXT: warn_invalid_asm_cast_lvalue CHECK-NEXT: warn_invalid_asm_cast_lvalue
CHECK-NEXT: warn_maynot_respond CHECK-NEXT: warn_maynot_respond
CHECK-NEXT: warn_method_param_redefinition CHECK-NEXT: warn_method_param_redefinition
CHECK-NEXT: warn_missing_case_for_condition CHECK-NEXT: warn_missing_case_for_condition
Show All 32 Lines

test/Sema/attr-unavailable-message.c

// RUN: %clang_cc1 -fsyntax-only -verify %s // RUN: %clang_cc1 -fsyntax-only -verify %s
// rdar: //6734520 // rdar: //6734520
void tooManyArgs() __attribute__((unavailable("a", "b"))); // expected-error {{'unavailable' attribute takes no more than 1 argument}}
int foo(int) __attribute__((__unavailable__("USE IFOO INSTEAD"))); // expected-note {{'foo' has been explicitly marked unavailable here}} int foo(int) __attribute__((__unavailable__("USE IFOO INSTEAD"))); // expected-note {{'foo' has been explicitly marked unavailable here}}
double dfoo(double) __attribute__((__unavailable__("NO LONGER"))); // expected-note 2 {{'dfoo' has been explicitly marked unavailable here}} double dfoo(double) __attribute__((__unavailable__("NO LONGER"))); // expected-note 2 {{'dfoo' has been explicitly marked unavailable here}}
void bar() __attribute__((__unavailable__)); // expected-note {{explicitly marked unavailable}} void bar() __attribute__((__unavailable__)); // expected-note {{explicitly marked unavailable}}
int quux(void) __attribute__((__unavailable__(12))); // expected-error {{'__unavailable__' attribute requires a string}} int quux(void) __attribute__((__unavailable__(12))); // expected-error {{'__unavailable__' attribute requires a string}}
#define ACCEPTABLE "Use something else" #define ACCEPTABLE "Use something else"
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/SemaCXX/constant-expression-cxx11.cpp

Show First 20 Lines • Show All 1,461 Lines • ▼ Show 20 Lines void f(int k) {
int arr[k]; // expected-warning {{C99}} int arr[k]; // expected-warning {{C99}}
constexpr int n = 1 + constexpr int n = 1 +
sizeof(arr) // expected-error {{constant expression}} sizeof(arr) // expected-error {{constant expression}}
* 3; * 3;
} }
} }
namespace CompoundLiteral { namespace CompoundLiteral {
// FIXME: // Matching GCC, file-scope array compound literals initialized by constants
// We don't model the semantics of this correctly: the compound literal is // are lifetime-extended.
// represented as a prvalue in the AST, but actually behaves like an lvalue. constexpr int *p = (int*)(int[1]){3}; // expected-warning {{C99}}
// We treat the compound literal as a temporary and refuse to produce a static_assert(*p == 3, "");
// pointer to it. This is OK: we're not required to treat this as a constant static_assert((int[2]){1, 2}[1] == 2, ""); // expected-warning {{C99}}
// in C++, and in C we model compound literals as lvalues.
constexpr int *p = (int*)(int[1]){0}; // expected-warning {{C99}} expected-error {{constant expression}} expected-note 2{{temporary}} // Other kinds are not.
struct X { int a[2]; };
constexpr int *n = (X){1, 2}.a; // expected-warning {{C99}} expected-warning {{temporary array}}
// expected-error@-1 {{constant expression}}
// expected-note@-2 {{pointer to subobject of temporary}}
// expected-note@-3 {{temporary created here}}
void f() {
static constexpr int *p = (int*)(int[1]){3}; // expected-warning {{C99}}
// expected-error@-1 {{constant expression}}
// expected-note@-2 {{pointer to subobject of temporary}}
// expected-note@-3 {{temporary created here}}
static_assert((int[2]){1, 2}[1] == 2, ""); // expected-warning {{C99}}
}
} }
namespace Vector { namespace Vector {
typedef int __attribute__((vector_size(16))) VI4; typedef int __attribute__((vector_size(16))) VI4;
constexpr VI4 f(int n) { constexpr VI4 f(int n) {
return VI4 { n * 3, n + 4, n - 5, n / 6 }; return VI4 { n * 3, n + 4, n - 5, n / 6 };
} }
constexpr auto v1 = f(10); constexpr auto v1 = f(10);
▲ Show 20 Lines • Show All 614 Lines • Show Last 20 Lines

test/SemaCXX/constexpr-value-init.cpp

Show All 28 Lines
constexpr D d2 = D(); // ok with DR1452 constexpr D d2 = D(); // ok with DR1452
static_assert(D().c == 0, ""); static_assert(D().c == 0, "");
static_assert(D().d == 0, ""); static_assert(D().d == 0, "");
struct V : virtual C {}; struct V : virtual C {};
template<typename T> struct Z : T { template<typename T> struct Z : T {
constexpr Z() : V() {} constexpr Z() : V() {}
}; };
constexpr int n = Z<V>().c; // expected-error {{constant expression}} expected-note {{virtual base class}} constexpr int n = Z<V>().c; // expected-error {{constant expression}} expected-note {{non-literal type 'Z<V>'}}
struct E { struct E {
A a[2]; A a[2];
}; };
constexpr E e; // ok constexpr E e; // ok
static_assert(e.a[0].a == 1, ""); static_assert(e.a[0].a == 1, "");
static_assert(e.a[0].b == 2, ""); static_assert(e.a[0].b == 2, "");
static_assert(e.a[1].a == 1, ""); static_assert(e.a[1].a == 1, "");
static_assert(e.a[1].b == 2, ""); static_assert(e.a[1].b == 2, "");

test/SemaCXX/cxx1z-noexcept-function-type.cpp

Show All 24 Lines
using DeducedType_a = void (*)(int) noexcept; using DeducedType_a = void (*)(int) noexcept;
void (*init_with_exact_type_b)(int) = redecl4<false>; void (*init_with_exact_type_b)(int) = redecl4<false>;
void (*init_with_mismatched_type_b)(int) noexcept = redecl4<false>; // expected-error {{does not match required type}} void (*init_with_mismatched_type_b)(int) noexcept = redecl4<false>; // expected-error {{does not match required type}}
auto deduce_auto_from_noexcept_function_ptr_b = redecl4<false>; auto deduce_auto_from_noexcept_function_ptr_b = redecl4<false>;
using DeducedType_b = decltype(deduce_auto_from_noexcept_function_ptr_b); using DeducedType_b = decltype(deduce_auto_from_noexcept_function_ptr_b);
using DeducedType_b = void (*)(int); using DeducedType_b = void (*)(int);
static_assert(noexcept(init_with_exact_type_a(0)));
static_assert(noexcept((+init_with_exact_type_a)(0)));
static_assert(!noexcept(init_with_exact_type_b(0)));
static_assert(!noexcept((+init_with_exact_type_b)(0)));
// Don't look through casts, use the direct type of the expression.
// FIXME: static_cast here would be reasonable, but is not currently permitted.
static_assert(noexcept(static_cast<decltype(init_with_exact_type_a)>(init_with_exact_type_b)(0))); // expected-error {{is not allowed}}
static_assert(noexcept(reinterpret_cast<decltype(init_with_exact_type_a)>(init_with_exact_type_b)(0)));
static_assert(!noexcept(static_cast<decltype(init_with_exact_type_b)>(init_with_exact_type_a)(0)));
template<bool B> auto get_fn() noexcept -> void (*)() noexcept(B) {}
static_assert(noexcept(get_fn<true>()()));
static_assert(!noexcept(get_fn<false>()()));
namespace DependentDefaultCtorExceptionSpec { namespace DependentDefaultCtorExceptionSpec {
template<typename> struct T { static const bool value = true; }; template<typename> struct T { static const bool value = true; };
template<class A> struct map { template<class A> struct map {
typedef A a; typedef A a;
map() noexcept(T<a>::value) {} map() noexcept(T<a>::value) {}
}; };
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

test/SemaCXX/expression-traits.cpp

// RUN: %clang_cc1 -fsyntax-only -verify -fcxx-exceptions %s // RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify -fcxx-exceptions %s
// //
// Tests for "expression traits" intrinsics such as __is_lvalue_expr. // Tests for "expression traits" intrinsics such as __is_lvalue_expr.
// //
// For the time being, these tests are written against the 2003 C++ // For the time being, these tests are written against the 2003 C++
// standard (ISO/IEC 14882:2003 -- see draft at // standard (ISO/IEC 14882:2003 -- see draft at
// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2001/n1316/). // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2001/n1316/).
// //
▲ Show 20 Lines • Show All 610 Lines • Show Last 20 Lines

test/SemaObjC/assign-rvalue-message.m

// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -Wno-objc-root-class %s // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -Wno-objc-root-class %s
// RUN: %clang_cc1 -x objective-c++ -triple x86_64-apple-darwin10 -fsyntax-only -verify -Wno-objc-root-class %s // RUN: %clang_cc1 -std=c++98 -x objective-c++ -triple x86_64-apple-darwin10 -fsyntax-only -verify -Wno-objc-root-class %s
// RUN: %clang_cc1 -std=c++11 -x objective-c++ -triple x86_64-apple-darwin10 -fsyntax-only -verify -Wno-objc-root-class %s
// rdar://9005189 // rdar://9005189
@interface Foo @interface Foo
@end @end
struct Bar { struct Bar {
int x; int x;
}; };
@implementation Foo { @implementation Foo {
struct Bar bar; struct Bar bar;
} }
- (const struct Bar)bar { - (const struct Bar)bar {
return bar; return bar;
} }
- (void)baz { - (void)baz {
bar.x = 0; bar.x = 0;
[self bar].x = 10; // expected-error {{assigning to 'readonly' return result of an Objective-C message not allowed}} [self bar].x = 10; // expected-error-re {{{{assigning to 'readonly' return result of an Objective-C message not allowed|expression is not assignable}}}}
} }
@end @end

tools/c-index-test/c-index-test.c

Show First 20 Lines • Show All 2,456 Lines • ▼ Show 20 Linesstatic void inspect_print_cursor(CXCursor Cursor) {
} }
printf("\n"); printf("\n");
} }
static void display_evaluate_results(CXEvalResult result) { static void display_evaluate_results(CXEvalResult result) {
switch (clang_EvalResult_getKind(result)) { switch (clang_EvalResult_getKind(result)) {
case CXEval_Int: case CXEval_Int:
{ {
int val = clang_EvalResult_getAsInt(result); printf("Kind: Int, ");
printf("Kind: Int , Value: %d", val); if (clang_EvalResult_isUnsignedInt(result)) {
unsigned long long val = clang_EvalResult_getAsUnsigned(result);
printf("unsigned, Value: %llu", val);
} else {
long long val = clang_EvalResult_getAsLongLong(result);
printf("Value: %lld", val);
}
break; break;
} }
case CXEval_Float: case CXEval_Float:
{ {
double val = clang_EvalResult_getAsDouble(result); double val = clang_EvalResult_getAsDouble(result);
printf("Kind: Float , Value: %f", val); printf("Kind: Float , Value: %f", val);
break; break;
} }
▲ Show 20 Lines • Show All 1,980 Lines • Show Last 20 Lines

tools/clang-format-vs/.gitignore

  • This file was added.
# Visual Studio files
.vs/
/packages/
/ClangFormat/obj/
/ClangFormat/bin/
# Generated and copied files
/ClangFormat/Key.snk
/ClangFormat/license.txt
/ClangFormat/clang-format.exe
/ClangFormat/source.extension.vsixmanifest

tools/clang-format-vs/CMakeLists.txt

Show All 12 Linesif (BUILD_CLANG_FORMAT_VS_PLUGIN)
if (NOT CLANG_FORMAT_VS_VERSION) if (NOT CLANG_FORMAT_VS_VERSION)
set(CLANG_FORMAT_VS_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}") set(CLANG_FORMAT_VS_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}")
endif() endif()
configure_file("source.extension.vsixmanifest.in" configure_file("source.extension.vsixmanifest.in"
"${CMAKE_CURRENT_SOURCE_DIR}/ClangFormat/source.extension.vsixmanifest") "${CMAKE_CURRENT_SOURCE_DIR}/ClangFormat/source.extension.vsixmanifest")
find_program(NUGET_EXE nuget PATHS ${NUGET_EXE_DIR})
if (NOT NUGET_EXE)
message(FATAL_ERROR "Could not find nuget.exe. Download from https://www.nuget.org/nuget.exe"
" and add parent directory to PATH or pass it via NUGET_EXE_DIR var.")
endif()
add_custom_target(clang_format_vsix ALL add_custom_target(clang_format_vsix ALL
devenv "${CMAKE_CURRENT_SOURCE_DIR}/ClangFormat.sln" /Build Release COMMAND ${NUGET_EXE} restore "${CMAKE_CURRENT_SOURCE_DIR}/ClangFormat.sln"
COMMAND devenv "${CMAKE_CURRENT_SOURCE_DIR}/ClangFormat.sln" /Build Release
DEPENDS clang_format_exe_for_vsix "${CMAKE_CURRENT_SOURCE_DIR}/ClangFormat/source.extension.vsixmanifest" DEPENDS clang_format_exe_for_vsix "${CMAKE_CURRENT_SOURCE_DIR}/ClangFormat/source.extension.vsixmanifest"
COMMAND ${CMAKE_COMMAND} -E copy_if_different COMMAND ${CMAKE_COMMAND} -E copy_if_different
"${CMAKE_CURRENT_SOURCE_DIR}/ClangFormat/bin/Release/ClangFormat.vsix" "${CMAKE_CURRENT_SOURCE_DIR}/ClangFormat/bin/Release/ClangFormat.vsix"
"${LLVM_TOOLS_BINARY_DIR}/ClangFormat.vsix" "${LLVM_TOOLS_BINARY_DIR}/ClangFormat.vsix"
DEPENDS clang_format_exe_for_vsix clang_format_license) DEPENDS clang_format_exe_for_vsix clang_format_license)
endif() endif()

tools/clang-format-vs/ClangFormat/ClangFormat.csproj

Show All 29 Lines <PropertyGroup>
<UpdatePeriodically>false</UpdatePeriodically> <UpdatePeriodically>false</UpdatePeriodically>
<UpdateRequired>false</UpdateRequired> <UpdateRequired>false</UpdateRequired>
<MapFileExtensions>true</MapFileExtensions> <MapFileExtensions>true</MapFileExtensions>
<ApplicationRevision>0</ApplicationRevision> <ApplicationRevision>0</ApplicationRevision>
<ApplicationVersion>1.0.0.%2a</ApplicationVersion> <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
<IsWebBootstrapper>false</IsWebBootstrapper> <IsWebBootstrapper>false</IsWebBootstrapper>
<UseApplicationTrust>false</UseApplicationTrust> <UseApplicationTrust>false</UseApplicationTrust>
<BootstrapperEnabled>true</BootstrapperEnabled> <BootstrapperEnabled>true</BootstrapperEnabled>
<TargetFrameworkProfile />
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols> <DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType> <DebugType>full</DebugType>
<Optimize>false</Optimize> <Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath> <OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants> <DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport> <ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel> <WarningLevel>4</WarningLevel>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType> <DebugType>pdbonly</DebugType>
<Optimize>true</Optimize> <Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath> <OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants> <DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport> <ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel> <WarningLevel>4</WarningLevel>
<RunCodeAnalysis>true</RunCodeAnalysis> <RunCodeAnalysis>true</RunCodeAnalysis>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>
<Reference Include="envdte, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<HintPath>..\packages\VSSDK.DTE.7.0.3\lib\net20\envdte.dll</HintPath>
<EmbedInteropTypes>False</EmbedInteropTypes>
</Reference>
<Reference Include="Microsoft.CSharp" /> <Reference Include="Microsoft.CSharp" />
<Reference Include="Microsoft.VisualStudio.CoreUtility, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" /> <Reference Include="Microsoft.VisualStudio.CoreUtility, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<Reference Include="Microsoft.VisualStudio.Editor, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" /> <HintPath>..\packages\VSSDK.CoreUtility.10.0.4\lib\net40\Microsoft.VisualStudio.CoreUtility.dll</HintPath>
<Reference Include="Microsoft.VisualStudio.OLE.Interop" /> <Private>False</Private>
<Reference Include="Microsoft.VisualStudio.Shell.Interop" /> </Reference>
<Reference Include="Microsoft.VisualStudio.Shell.Interop.8.0" /> <Reference Include="Microsoft.VisualStudio.Editor, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<Reference Include="Microsoft.VisualStudio.Shell.Interop.9.0" /> <HintPath>..\packages\VSSDK.Editor.10.0.4\lib\net40\Microsoft.VisualStudio.Editor.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.OLE.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<HintPath>..\packages\VSSDK.OLE.Interop.7.0.4\lib\net20\Microsoft.VisualStudio.OLE.Interop.dll</HintPath>
<Private>True</Private>
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Shell.10.0, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\VSSDK.Shell.10.10.0.3\lib\net40\Microsoft.VisualStudio.Shell.10.0.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Shell.Immutable.10.0, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\VSSDK.Shell.Immutable.10.10.0.3\lib\net40\Microsoft.VisualStudio.Shell.Immutable.10.0.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Shell.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<HintPath>..\packages\VSSDK.Shell.Interop.7.0.4\lib\net20\Microsoft.VisualStudio.Shell.Interop.dll</HintPath>
<Private>True</Private>
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Shell.Interop.8.0, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<HintPath>..\packages\VSSDK.Shell.Interop.8.8.0.3\lib\net20\Microsoft.VisualStudio.Shell.Interop.8.0.dll</HintPath>
<Private>True</Private>
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Shell.Interop.10.0" /> <Reference Include="Microsoft.VisualStudio.Shell.Interop.10.0" />
<Reference Include="Microsoft.VisualStudio.TextManager.Interop" /> <Reference Include="Microsoft.VisualStudio.Shell.Interop.9.0, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<Reference Include="Microsoft.VisualStudio.Shell.10.0"> <HintPath>..\packages\VSSDK.Shell.Interop.9.9.0.3\lib\net20\Microsoft.VisualStudio.Shell.Interop.9.0.dll</HintPath>
<Private>false</Private> <Private>True</Private>
</Reference> <Private>False</Private>
<Reference Include="Microsoft.VisualStudio.Text.Data, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" /> </Reference>
<Reference Include="Microsoft.VisualStudio.Text.Logic, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" /> <Reference Include="Microsoft.VisualStudio.Text.Data, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<Reference Include="Microsoft.VisualStudio.Text.UI, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" /> <HintPath>..\packages\VSSDK.Text.10.0.4\lib\net40\Microsoft.VisualStudio.Text.Data.dll</HintPath>
<Reference Include="Microsoft.VisualStudio.Text.UI.Wpf, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" /> <Private>False</Private>
<Reference Include="Microsoft.VisualStudio.TextManager.Interop" /> </Reference>
<Reference Include="Microsoft.VisualStudio.Shell.Immutable.10.0" /> <Reference Include="Microsoft.VisualStudio.Text.Logic, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\VSSDK.Text.10.0.4\lib\net40\Microsoft.VisualStudio.Text.Logic.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Text.UI, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\VSSDK.Text.10.0.4\lib\net40\Microsoft.VisualStudio.Text.UI.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Text.UI.Wpf, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\VSSDK.Text.10.0.4\lib\net40\Microsoft.VisualStudio.Text.UI.Wpf.dll</HintPath>
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.TextManager.Interop">
<HintPath>..\packages\VSSDK.TextManager.Interop.7.0.4\lib\net20\Microsoft.VisualStudio.TextManager.Interop.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.TextManager.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.TextManager.Interop.8.0, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<HintPath>..\packages\VSSDK.TextManager.Interop.8.8.0.4\lib\net20\Microsoft.VisualStudio.TextManager.Interop.8.0.dll</HintPath>
<Private>True</Private>
<Private>False</Private>
</Reference>
<Reference Include="PresentationCore" />
<Reference Include="PresentationFramework" />
<Reference Include="stdole, Version=7.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<HintPath>..\packages\VSSDK.DTE.7.0.3\lib\net20\stdole.dll</HintPath>
<EmbedInteropTypes>False</EmbedInteropTypes>
</Reference>
<Reference Include="System" /> <Reference Include="System" />
<Reference Include="System.ComponentModel.Composition" />
<Reference Include="System.Core" /> <Reference Include="System.Core" />
<Reference Include="System.Data" /> <Reference Include="System.Data" />
<Reference Include="System.Design" /> <Reference Include="System.Design" />
<Reference Include="System.Drawing" /> <Reference Include="System.Drawing" />
<Reference Include="System.Windows.Forms" /> <Reference Include="System.Windows.Forms" />
<Reference Include="System.Xml" /> <Reference Include="System.Xml" />
<Reference Include="System.Xml.Linq" /> <Reference Include="System.Xml.Linq" />
<Reference Include="WindowsBase" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<COMReference Include="EnvDTE"> <COMReference Include="EnvDTE">
<Guid>{80CC9F66-E7D8-4DDD-85B6-D9E6CD0E93E2}</Guid> <Guid>{80CC9F66-E7D8-4DDD-85B6-D9E6CD0E93E2}</Guid>
<VersionMajor>8</VersionMajor> <VersionMajor>8</VersionMajor>
<VersionMinor>0</VersionMinor> <VersionMinor>0</VersionMinor>
<Lcid>0</Lcid> <Lcid>0</Lcid>
<WrapperTool>primary</WrapperTool> <WrapperTool>primary</WrapperTool>
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines <ItemGroup>
</EmbeddedResource> </EmbeddedResource>
<EmbeddedResource Include="VSPackage.resx"> <EmbeddedResource Include="VSPackage.resx">
<MergeWithCTO>true</MergeWithCTO> <MergeWithCTO>true</MergeWithCTO>
<ManifestResourceName>VSPackage</ManifestResourceName> <ManifestResourceName>VSPackage</ManifestResourceName>
</EmbeddedResource> </EmbeddedResource>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="Key.snk" /> <None Include="Key.snk" />
<None Include="packages.config" />
<None Include="source.extension.vsixmanifest"> <None Include="source.extension.vsixmanifest">
<SubType>Designer</SubType> <SubType>Designer</SubType>
</None> </None>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<VSCTCompile Include="ClangFormat.vsct"> <VSCTCompile Include="ClangFormat.vsct">
<ResourceName>Menus.ctmenu</ResourceName> <ResourceName>Menus.ctmenu</ResourceName>
</VSCTCompile> </VSCTCompile>
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
</PropertyGroup> </PropertyGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it. <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets. Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild"> <Target Name="BeforeBuild">
</Target> </Target>
<Target Name="AfterBuild"> <Target Name="AfterBuild">
</Target> </Target>
--> -->
</Project> </Project>
No newline at end of file

tools/clang-format-vs/ClangFormat/packages.config

  • This file was added.
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="VSSDK.CoreUtility" version="10.0.4" targetFramework="net40" />
<package id="VSSDK.CoreUtility.10" version="10.0.4" targetFramework="net40" />
<package id="VSSDK.DTE" version="7.0.3" targetFramework="net40" />
<package id="VSSDK.Editor" version="10.0.4" targetFramework="net40" />
<package id="VSSDK.Editor.10" version="10.0.4" targetFramework="net40" />
<package id="VSSDK.IDE" version="7.0.4" targetFramework="net40" />
<package id="VSSDK.IDE.10" version="10.0.4" targetFramework="net40" />
<package id="VSSDK.IDE.8" version="8.0.4" targetFramework="net40" />
<package id="VSSDK.IDE.9" version="9.0.3" targetFramework="net40" />
<package id="VSSDK.OLE.Interop" version="7.0.4" targetFramework="net40" />
<package id="VSSDK.Shell.10" version="10.0.3" targetFramework="net40" />
<package id="VSSDK.Shell.Immutable.10" version="10.0.3" targetFramework="net40" />
<package id="VSSDK.Shell.Interop" version="7.0.4" targetFramework="net40" />
<package id="VSSDK.Shell.Interop.8" version="8.0.3" targetFramework="net40" />
<package id="VSSDK.Shell.Interop.9" version="9.0.3" targetFramework="net40" />
<package id="VSSDK.Text" version="10.0.4" targetFramework="net40" />
<package id="VSSDK.Text.10" version="10.0.4" targetFramework="net40" />
<package id="VSSDK.TextManager.Interop" version="7.0.4" targetFramework="net40" />
<package id="VSSDK.TextManager.Interop.8" version="8.0.4" targetFramework="net40" />
</packages>
No newline at end of file

tools/clang-format-vs/README.txt

This directory contains a VSPackage project to generate a Visual Studio extension This directory contains a VSPackage project to generate a Visual Studio extension
for clang-format. for clang-format.
Build prerequisites are: Build prerequisites are:
- Visual Studio 2013 Professional - Visual Studio 2015
- Visual Studio 2013 SDK - Extensions SDK (you'll be prompted to install it if you open ClangFormat.sln)
- Visual Studio 2010 Professional (?)
- Visual Studio 2010 SDK (?)
The extension is built using CMake by setting BUILD_CLANG_FORMAT_VS_PLUGIN=ON The extension is built using CMake to generate the usual LLVM.sln by setting
when configuring a Clang build, and building the clang_format_vsix target. the following CMake vars:
- BUILD_CLANG_FORMAT_VS_PLUGIN=ON
- NUGET_EXE_PATH=path/to/nuget_dir (unless nuget.exe is already available in PATH)
example:
cd /d C:\code\llvm
mkdir build & cd build
cmake -DBUILD_CLANG_FORMAT_VS_PLUGIN=ON -DNUGET_EXE_PATH=C:\nuget ..
Once LLVM.sln is generated, build the clang_format_vsix target, which will build
ClangFormat.sln, the C# extension application.
The CMake build will copy clang-format.exe and LICENSE.TXT into the ClangFormat/ The CMake build will copy clang-format.exe and LICENSE.TXT into the ClangFormat/
directory so they can be bundled with the plug-in, as well as creating directory so they can be bundled with the plug-in, as well as creating
ClangFormat/source.extension.vsixmanifest. Once the plug-in has been built with ClangFormat/source.extension.vsixmanifest. Once the plug-in has been built with
CMake once, it can be built manually from the ClangFormat.sln solution in Visual CMake once, it can be built manually from the ClangFormat.sln solution in Visual
Studio. Studio.

tools/clang-format/clang-format-diff.py

Show All 11 Lines
r""" r"""
ClangFormat Diff Reformatter ClangFormat Diff Reformatter
============================ ============================
This script reads input from a unified diff and reformats all the changed This script reads input from a unified diff and reformats all the changed
lines. This is useful to reformat all the lines touched by a specific patch. lines. This is useful to reformat all the lines touched by a specific patch.
Example usage for git/svn users: Example usage for git/svn users:
git diff -U0 HEAD^ | clang-format-diff.py -p1 -i git diff -U0 --no-color HEAD^ | clang-format-diff.py -p1 -i
svn diff --diff-cmd=diff -x-U0 | clang-format-diff.py -i svn diff --diff-cmd=diff -x-U0 | clang-format-diff.py -i
""" """
import argparse import argparse
import difflib import difflib
import re import re
import string import string
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

tools/driver/cc1as_main.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Linesstruct AssemblerInvocation {
/// If given, the name of the target CPU to determine which instructions /// If given, the name of the target CPU to determine which instructions
/// are legal. /// are legal.
std::string CPU; std::string CPU;
/// The list of target specific features to enable or disable -- this should /// The list of target specific features to enable or disable -- this should
/// be a list of strings starting with '+' or '-'. /// be a list of strings starting with '+' or '-'.
std::vector<std::string> Features; std::vector<std::string> Features;
/// The list of symbol definitions.
std::vector<std::string> SymbolDefs;
/// @} /// @}
/// @name Language Options /// @name Language Options
/// @{ /// @{
std::vector<std::string> IncludePaths; std::vector<std::string> IncludePaths;
unsigned NoInitialTextSection : 1; unsigned NoInitialTextSection : 1;
unsigned SaveTemporaryLabels : 1; unsigned SaveTemporaryLabels : 1;
unsigned GenDwarfForAssembly : 1; unsigned GenDwarfForAssembly : 1;
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Linesbool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
// Assemble Options // Assemble Options
Opts.RelaxAll = Args.hasArg(OPT_mrelax_all); Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack); Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings); Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic"); Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
Opts.IncrementalLinkerCompatible = Opts.IncrementalLinkerCompatible =
Args.hasArg(OPT_mincremental_linker_compatible); Args.hasArg(OPT_mincremental_linker_compatible);
Opts.SymbolDefs = Args.getAllArgValues(OPT_defsym);
return Success; return Success;
} }
static std::unique_ptr<raw_fd_ostream> static std::unique_ptr<raw_fd_ostream>
getOutputStream(AssemblerInvocation &Opts, DiagnosticsEngine &Diags, getOutputStream(AssemblerInvocation &Opts, DiagnosticsEngine &Diags,
bool Binary) { bool Binary) {
if (Opts.OutputPath.empty()) if (Opts.OutputPath.empty())
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 Linesstatic bool ExecuteAssembler(AssemblerInvocation &Opts,
// FIXME: init MCTargetOptions from sanitizer flags here. // FIXME: init MCTargetOptions from sanitizer flags here.
MCTargetOptions Options; MCTargetOptions Options;
std::unique_ptr<MCTargetAsmParser> TAP( std::unique_ptr<MCTargetAsmParser> TAP(
TheTarget->createMCAsmParser(*STI, *Parser, *MCII, Options)); TheTarget->createMCAsmParser(*STI, *Parser, *MCII, Options));
if (!TAP) if (!TAP)
Failed = Diags.Report(diag::err_target_unknown_triple) << Opts.Triple; Failed = Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
// Set values for symbols, if any.
for (auto &S : Opts.SymbolDefs) {
if (Ctx.setSymbolValue(Parser->getStreamer(), S)) {
Failed = true;
break;
}
}
if (!Failed) { if (!Failed) {
Parser->setTargetParser(*TAP.get()); Parser->setTargetParser(*TAP.get());
Failed = Parser->Run(Opts.NoInitialTextSection); Failed = Parser->Run(Opts.NoInitialTextSection);
} }
// Close Streamer first. // Close Streamer first.
// It might have a reference to the output stream. // It might have a reference to the output stream.
Str.reset(); Str.reset();
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

tools/libclang/CIndex.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,512 Lines • ▼ Show 20 Lines if (arg->getStmtClass() == Stmt::ImplicitCastExprClass) {
return nullptr; return nullptr;
} }
return S; return S;
} }
struct ExprEvalResult { struct ExprEvalResult {
CXEvalResultKind EvalType; CXEvalResultKind EvalType;
union { union {
int intVal; unsigned long long unsignedVal;
long long intVal;
double floatVal; double floatVal;
char *stringVal; char *stringVal;
} EvalData; } EvalData;
bool IsUnsignedInt;
~ExprEvalResult() { ~ExprEvalResult() {
if (EvalType != CXEval_UnExposed && EvalType != CXEval_Float && if (EvalType != CXEval_UnExposed && EvalType != CXEval_Float &&
EvalType != CXEval_Int) { EvalType != CXEval_Int) {
delete EvalData.stringVal; delete EvalData.stringVal;
} }
} }
}; };
void clang_EvalResult_dispose(CXEvalResult E) { void clang_EvalResult_dispose(CXEvalResult E) {
delete static_cast<ExprEvalResult *>(E); delete static_cast<ExprEvalResult *>(E);
} }
CXEvalResultKind clang_EvalResult_getKind(CXEvalResult E) { CXEvalResultKind clang_EvalResult_getKind(CXEvalResult E) {
if (!E) { if (!E) {
return CXEval_UnExposed; return CXEval_UnExposed;
} }
return ((ExprEvalResult *)E)->EvalType; return ((ExprEvalResult *)E)->EvalType;
} }
int clang_EvalResult_getAsInt(CXEvalResult E) { int clang_EvalResult_getAsInt(CXEvalResult E) {
return clang_EvalResult_getAsLongLong(E);
}
long long clang_EvalResult_getAsLongLong(CXEvalResult E) {
if (!E) {
return 0;
}
ExprEvalResult *Result = (ExprEvalResult*)E;
if (Result->IsUnsignedInt)
return Result->EvalData.unsignedVal;
return Result->EvalData.intVal;
}
unsigned clang_EvalResult_isUnsignedInt(CXEvalResult E) {
return ((ExprEvalResult *)E)->IsUnsignedInt;
}
unsigned long long clang_EvalResult_getAsUnsigned(CXEvalResult E) {
if (!E) { if (!E) {
return 0; return 0;
} }
return ((ExprEvalResult *)E)->EvalData.intVal;
ExprEvalResult *Result = (ExprEvalResult*)E;
if (Result->IsUnsignedInt)
return Result->EvalData.unsignedVal;
return Result->EvalData.intVal;
} }
double clang_EvalResult_getAsDouble(CXEvalResult E) { double clang_EvalResult_getAsDouble(CXEvalResult E) {
if (!E) { if (!E) {
return 0; return 0;
} }
return ((ExprEvalResult *)E)->EvalData.floatVal; return ((ExprEvalResult *)E)->EvalData.floatVal;
} }
Show All 14 Linesstatic const ExprEvalResult* evaluateExpr(Expr *expr, CXCursor C) {
expr = expr->IgnoreParens(); expr = expr->IgnoreParens();
if (!expr->EvaluateAsRValue(ER, ctx)) if (!expr->EvaluateAsRValue(ER, ctx))
return nullptr; return nullptr;
QualType rettype; QualType rettype;
CallExpr *callExpr; CallExpr *callExpr;
auto result = llvm::make_unique<ExprEvalResult>(); auto result = llvm::make_unique<ExprEvalResult>();
result->EvalType = CXEval_UnExposed; result->EvalType = CXEval_UnExposed;
result->IsUnsignedInt = false;
if (ER.Val.isInt()) { if (ER.Val.isInt()) {
result->EvalType = CXEval_Int; result->EvalType = CXEval_Int;
result->EvalData.intVal = ER.Val.getInt().getExtValue();
auto& val = ER.Val.getInt();
if (val.isUnsigned()) {
result->IsUnsignedInt = true;
result->EvalData.unsignedVal = val.getZExtValue();
} else {
result->EvalData.intVal = val.getExtValue();
}
return result.release(); return result.release();
} }
if (ER.Val.isFloat()) { if (ER.Val.isFloat()) {
llvm::SmallVector<char, 100> Buffer; llvm::SmallVector<char, 100> Buffer;
ER.Val.getFloat().toString(Buffer); ER.Val.getFloat().toString(Buffer);
std::string floatStr(Buffer.data(), Buffer.size()); std::string floatStr(Buffer.data(), Buffer.size());
result->EvalType = CXEval_Float; result->EvalType = CXEval_Float;
▲ Show 20 Lines • Show All 4,548 Lines • Show Last 20 Lines

tools/libclang/libclang.exports

Show First 20 Lines • Show All 329 Lines • ▼ Show 20 Lines
clang_Type_getObjCEncoding clang_Type_getObjCEncoding
clang_Cursor_isMacroFunctionLike clang_Cursor_isMacroFunctionLike
clang_Cursor_isMacroBuiltin clang_Cursor_isMacroBuiltin
clang_Cursor_isFunctionInlined clang_Cursor_isFunctionInlined
clang_Cursor_hasAttrs clang_Cursor_hasAttrs
clang_Cursor_Evaluate clang_Cursor_Evaluate
clang_EvalResult_getKind clang_EvalResult_getKind
clang_EvalResult_getAsInt clang_EvalResult_getAsInt
clang_EvalResult_getAsLongLong
clang_EvalResult_getAsUnsigned
clang_EvalResult_isUnsignedInt
clang_EvalResult_getAsDouble clang_EvalResult_getAsDouble
clang_EvalResult_getAsStr clang_EvalResult_getAsStr
clang_EvalResult_dispose clang_EvalResult_dispose

unittests/ASTMatchers/ASTMatchersNodeTest.cpp

Show First 20 Lines • Show All 588 Lines • ▼ Show 20 Lines notMatches(ClassString +
"void run() {" "void run() {"
" string* s = GetStringPointer();" " string* s = GetStringPointer();"
" FunctionTakesStringPtr(GetStringPointer());" " FunctionTakesStringPtr(GetStringPointer());"
" FunctionTakesStringPtr(s);" " FunctionTakesStringPtr(s);"
"}", "}",
materializeTemporaryExpr())); materializeTemporaryExpr()));
EXPECT_TRUE( EXPECT_TRUE(
notMatches(ClassString + matches(ClassString +
"string GetStringByValue();" "string GetStringByValue();"
"void run() { int k = GetStringByValue().length(); }", "void run() { int k = GetStringByValue().length(); }",
materializeTemporaryExpr())); materializeTemporaryExpr()));
EXPECT_TRUE( EXPECT_TRUE(
notMatches(ClassString + notMatches(ClassString +
"string GetStringByValue();" "string GetStringByValue();"
"void run() { GetStringByValue(); }", "void run() { GetStringByValue(); }",
▲ Show 20 Lines • Show All 939 Lines • Show Last 20 Lines

unittests/Analysis/CFGTest.cpp

Show All 12 Lines
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <string> #include <string>
#include <vector> #include <vector>
namespace clang { namespace clang {
namespace analysis { namespace analysis {
namespace { namespace {
// Constructing a CFG for a range-based for over a dependent type fails (but enum BuildResult {
// should not crash). ToolFailed,
TEST(CFG, RangeBasedForOverDependentType) { ToolRan,
const char *Code = "class Foo;\n" SawFunctionBody,
"template <typename T>\n" BuiltCFG,
"void f(const T &Range) {\n" };
" for (const Foo *TheFoo : Range) {\n"
" }\n"
"}\n";
class CFGCallback : public ast_matchers::MatchFinder::MatchCallback { class CFGCallback : public ast_matchers::MatchFinder::MatchCallback {
public: public:
bool SawFunctionBody = false; BuildResult TheBuildResult = ToolRan;
void run(const ast_matchers::MatchFinder::MatchResult &Result) override { void run(const ast_matchers::MatchFinder::MatchResult &Result) override {
const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func"); const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
Stmt *Body = Func->getBody(); Stmt *Body = Func->getBody();
if (!Body) if (!Body)
return; return;
SawFunctionBody = true; TheBuildResult = SawFunctionBody;
std::unique_ptr<CFG> cfg = if (CFG::buildCFG(nullptr, Body, Result.Context, CFG::BuildOptions()))
CFG::buildCFG(nullptr, Body, Result.Context, CFG::BuildOptions()); TheBuildResult = BuiltCFG;
EXPECT_EQ(nullptr, cfg);
} }
} Callback; };
BuildResult BuildCFG(const char *Code) {
CFGCallback Callback;
ast_matchers::MatchFinder Finder; ast_matchers::MatchFinder Finder;
Finder.addMatcher(ast_matchers::functionDecl().bind("func"), &Callback); Finder.addMatcher(ast_matchers::functionDecl().bind("func"), &Callback);
std::unique_ptr<tooling::FrontendActionFactory> Factory( std::unique_ptr<tooling::FrontendActionFactory> Factory(
tooling::newFrontendActionFactory(&Finder)); tooling::newFrontendActionFactory(&Finder));
std::vector<std::string> Args = {"-std=c++11", "-fno-delayed-template-parsing"}; std::vector<std::string> Args = {"-std=c++11", "-fno-delayed-template-parsing"};
ASSERT_TRUE(tooling::runToolOnCodeWithArgs(Factory->create(), Code, Args)); if (!tooling::runToolOnCodeWithArgs(Factory->create(), Code, Args))
EXPECT_TRUE(Callback.SawFunctionBody); return ToolFailed;
return Callback.TheBuildResult;
}
// Constructing a CFG for a range-based for over a dependent type fails (but
// should not crash).
TEST(CFG, RangeBasedForOverDependentType) {
const char *Code = "class Foo;\n"
"template <typename T>\n"
"void f(const T &Range) {\n"
" for (const Foo *TheFoo : Range) {\n"
" }\n"
"}\n";
EXPECT_EQ(SawFunctionBody, BuildCFG(Code));
}
// Constructing a CFG containing a delete expression on a dependent type should
// not crash.
TEST(CFG, DeleteExpressionOnDependentType) {
const char *Code = "template<class T>\n"
"void f(T t) {\n"
" delete t;\n"
"}\n";
EXPECT_EQ(BuiltCFG, BuildCFG(Code));
} }
} // namespace } // namespace
} // namespace analysis } // namespace analysis
} // namespace clang } // namespace clang

unittests/Format/CleanupTest.cpp

Show First 20 Lines • Show All 833 Lines • ▼ Show 20 LinesTEST_F(CleanUpReplacementsTest, InsertionAndDeleteHeader) {
std::string Expected = "#include \"a.h\"\n" std::string Expected = "#include \"a.h\"\n"
"\n" "\n"
"#include <map>\n"; "#include <map>\n";
tooling::Replacements Replaces = toReplacements( tooling::Replacements Replaces = toReplacements(
{createDeletion("<vector>"), createInsertion("#include <map>")}); {createDeletion("<vector>"), createInsertion("#include <map>")});
EXPECT_EQ(Expected, apply(Code, Replaces)); EXPECT_EQ(Expected, apply(Code, Replaces));
} }
TEST_F(CleanUpReplacementsTest, NoInsertionAfterCode) {
std::string Code = "#include \"a.h\"\n"
"void f() {}\n"
"#include \"b.h\"\n";
std::string Expected = "#include \"a.h\"\n"
"#include \"c.h\"\n"
"void f() {}\n"
"#include \"b.h\"\n";
tooling::Replacements Replaces = toReplacements(
{createInsertion("#include \"c.h\"")});
EXPECT_EQ(Expected, apply(Code, Replaces));
}
TEST_F(CleanUpReplacementsTest, NoInsertionInStringLiteral) {
std::string Code = "#include \"a.h\"\n"
"const char[] = R\"(\n"
"#include \"b.h\"\n"
")\";\n";
std::string Expected = "#include \"a.h\"\n"
"#include \"c.h\"\n"
"const char[] = R\"(\n"
"#include \"b.h\"\n"
")\";\n";
tooling::Replacements Replaces =
toReplacements({createInsertion("#include \"c.h\"")});
EXPECT_EQ(Expected, apply(Code, Replaces));
}
TEST_F(CleanUpReplacementsTest, NoInsertionAfterOtherDirective) {
std::string Code = "#include \"a.h\"\n"
"#ifdef X\n"
"#include \"b.h\"\n"
"#endif\n";
std::string Expected = "#include \"a.h\"\n"
"#include \"c.h\"\n"
"#ifdef X\n"
"#include \"b.h\"\n"
"#endif\n";
tooling::Replacements Replaces = toReplacements(
{createInsertion("#include \"c.h\"")});
EXPECT_EQ(Expected, apply(Code, Replaces));
}
TEST_F(CleanUpReplacementsTest, CanInsertAfterLongSystemInclude) {
std::string Code = "#include \"a.h\"\n"
"// comment\n\n"
"#include <a/b/c/d/e.h>\n";
std::string Expected = "#include \"a.h\"\n"
"// comment\n\n"
"#include <a/b/c/d/e.h>\n"
"#include <x.h>\n";
tooling::Replacements Replaces =
toReplacements({createInsertion("#include <x.h>")});
EXPECT_EQ(Expected, apply(Code, Replaces));
}
TEST_F(CleanUpReplacementsTest, CanInsertAfterComment) {
std::string Code = "#include \"a.h\"\n"
"// Comment\n"
"\n"
"/* Comment */\n"
"// Comment\n"
"\n"
"#include \"b.h\"\n";
std::string Expected = "#include \"a.h\"\n"
"// Comment\n"
"\n"
"/* Comment */\n"
"// Comment\n"
"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n";
tooling::Replacements Replaces =
toReplacements({createInsertion("#include \"c.h\"")});
EXPECT_EQ(Expected, apply(Code, Replaces));
}
TEST_F(CleanUpReplacementsTest, CanDeleteAfterCode) {
std::string Code = "#include \"a.h\"\n"
"void f() {}\n"
"#include \"b.h\"\n";
std::string Expected = "#include \"a.h\"\n"
"void f() {}\n";
tooling::Replacements Replaces = toReplacements({createDeletion("\"b.h\"")});
EXPECT_EQ(Expected, apply(Code, Replaces));
}
} // end namespace } // end namespace
} // end namespace format } // end namespace format
} // end namespace clang } // end namespace clang

unittests/Tooling/CompilationDatabaseTest.cpp

Show All 38 LinesTEST(JSONCompilationDatabase, ErrsOnInvalidFormat) {
expectFailure("[{\"directory\":\"\",\"file\":\"\"}]", "Missing command or arguments"); expectFailure("[{\"directory\":\"\",\"file\":\"\"}]", "Missing command or arguments");
expectFailure("[{\"command\":\"\",\"file\":\"\"}]", "Missing directory"); expectFailure("[{\"command\":\"\",\"file\":\"\"}]", "Missing directory");
expectFailure("[{\"directory\":\"\",\"arguments\":[]}]", "Missing file"); expectFailure("[{\"directory\":\"\",\"arguments\":[]}]", "Missing file");
expectFailure("[{\"arguments\":\"\",\"file\":\"\"}]", "Missing directory"); expectFailure("[{\"arguments\":\"\",\"file\":\"\"}]", "Missing directory");
expectFailure("[{\"directory\":\"\",\"arguments\":\"\",\"file\":\"\"}]", "Arguments not array"); expectFailure("[{\"directory\":\"\",\"arguments\":\"\",\"file\":\"\"}]", "Arguments not array");
expectFailure("[{\"directory\":\"\",\"command\":[],\"file\":\"\"}]", "Command not string"); expectFailure("[{\"directory\":\"\",\"command\":[],\"file\":\"\"}]", "Command not string");
expectFailure("[{\"directory\":\"\",\"arguments\":[[]],\"file\":\"\"}]", expectFailure("[{\"directory\":\"\",\"arguments\":[[]],\"file\":\"\"}]",
"Arguments contain non-string"); "Arguments contain non-string");
expectFailure("[{\"output\":[]}]", "Expected strings as value.");
} }
static std::vector<std::string> getAllFiles(StringRef JSONDatabase, static std::vector<std::string> getAllFiles(StringRef JSONDatabase,
std::string &ErrorMessage, std::string &ErrorMessage,
JSONCommandLineSyntax Syntax) { JSONCommandLineSyntax Syntax) {
std::unique_ptr<CompilationDatabase> Database( std::unique_ptr<CompilationDatabase> Database(
JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage, JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage,
Syntax)); Syntax));
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 LinesTEST(JSONCompilationDatabase, GetAllCompileCommands) {
EXPECT_EQ( EXPECT_EQ(
0u, getAllCompileCommands(JSONCommandLineSyntax::Gnu, "[]", ErrorMessage) 0u, getAllCompileCommands(JSONCommandLineSyntax::Gnu, "[]", ErrorMessage)
.size()) .size())
<< ErrorMessage; << ErrorMessage;
StringRef Directory1("//net/dir1"); StringRef Directory1("//net/dir1");
StringRef FileName1("file1"); StringRef FileName1("file1");
StringRef Command1("command1"); StringRef Command1("command1");
StringRef Output1("file1.o");
StringRef Directory2("//net/dir2"); StringRef Directory2("//net/dir2");
StringRef FileName2("file2"); StringRef FileName2("file2");
StringRef Command2("command2"); StringRef Command2("command2");
StringRef Output2("");
std::vector<CompileCommand> Commands = getAllCompileCommands( std::vector<CompileCommand> Commands = getAllCompileCommands(
JSONCommandLineSyntax::Gnu, JSONCommandLineSyntax::Gnu,
("[{\"directory\":\"" + Directory1 + "\"," + "\"command\":\"" + Command1 + ("[{\"directory\":\"" + Directory1 + "\"," + "\"command\":\"" + Command1 +
"\"," "\","
"\"file\":\"" + "\"file\":\"" +
FileName1 + "\"}," FileName1 + "\", \"output\":\"" +
Output1 + "\"},"
" {\"directory\":\"" + " {\"directory\":\"" +
Directory2 + "\"," + "\"command\":\"" + Command2 + "\"," Directory2 + "\"," + "\"command\":\"" + Command2 + "\","
"\"file\":\"" + "\"file\":\"" +
FileName2 + "\"}]") FileName2 + "\"}]")
.str(), .str(),
ErrorMessage); ErrorMessage);
EXPECT_EQ(2U, Commands.size()) << ErrorMessage; EXPECT_EQ(2U, Commands.size()) << ErrorMessage;
EXPECT_EQ(Directory1, Commands[0].Directory) << ErrorMessage; EXPECT_EQ(Directory1, Commands[0].Directory) << ErrorMessage;
EXPECT_EQ(FileName1, Commands[0].Filename) << ErrorMessage; EXPECT_EQ(FileName1, Commands[0].Filename) << ErrorMessage;
EXPECT_EQ(Output1, Commands[0].Output) << ErrorMessage;
ASSERT_EQ(1u, Commands[0].CommandLine.size()); ASSERT_EQ(1u, Commands[0].CommandLine.size());
EXPECT_EQ(Command1, Commands[0].CommandLine[0]) << ErrorMessage; EXPECT_EQ(Command1, Commands[0].CommandLine[0]) << ErrorMessage;
EXPECT_EQ(Directory2, Commands[1].Directory) << ErrorMessage; EXPECT_EQ(Directory2, Commands[1].Directory) << ErrorMessage;
EXPECT_EQ(FileName2, Commands[1].Filename) << ErrorMessage; EXPECT_EQ(FileName2, Commands[1].Filename) << ErrorMessage;
EXPECT_EQ(Output2, Commands[1].Output) << ErrorMessage;
ASSERT_EQ(1u, Commands[1].CommandLine.size()); ASSERT_EQ(1u, Commands[1].CommandLine.size());
EXPECT_EQ(Command2, Commands[1].CommandLine[0]) << ErrorMessage; EXPECT_EQ(Command2, Commands[1].CommandLine[0]) << ErrorMessage;
// Check that order is preserved. // Check that order is preserved.
Commands = getAllCompileCommands( Commands = getAllCompileCommands(
JSONCommandLineSyntax::Gnu, JSONCommandLineSyntax::Gnu,
("[{\"directory\":\"" + Directory2 + "\"," + "\"command\":\"" + Command2 + ("[{\"directory\":\"" + Directory2 + "\"," + "\"command\":\"" + Command2 +
"\"," "\","
▲ Show 20 Lines • Show All 453 Lines • Show Last 20 Lines

utils/TableGen/ClangASTNodesEmitter.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesclass ClangASTNodesEmitter {
// Return the name to be printed in the base field. Normally this is // Return the name to be printed in the base field. Normally this is
// the record's name plus the base suffix, but if it is the root node and // the record's name plus the base suffix, but if it is the root node and
// the suffix is non-empty, it's just the suffix. // the suffix is non-empty, it's just the suffix.
std::string baseName(Record &R) { std::string baseName(Record &R) {
if (&R == &Root && !BaseSuffix.empty()) if (&R == &Root && !BaseSuffix.empty())
return BaseSuffix; return BaseSuffix;
return R.getName() + BaseSuffix; return R.getName().str() + BaseSuffix;
} }
std::pair<Record *, Record *> EmitNode (const ChildMap &Tree, raw_ostream& OS, std::pair<Record *, Record *> EmitNode (const ChildMap &Tree, raw_ostream& OS,
Record *Base); Record *Base);
public: public:
explicit ClangASTNodesEmitter(RecordKeeper &R, const std::string &N, explicit ClangASTNodesEmitter(RecordKeeper &R, const std::string &N,
const std::string &S) const std::string &S)
: Records(R), Root(N, SMLoc(), R), BaseSuffix(S) : Records(R), Root(N, SMLoc(), R), BaseSuffix(S)
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

utils/TableGen/ClangAttrEmitter.cpp

Show First 20 Lines • Show All 2,534 Lines • ▼ Show 20 Lines
static void emitArgInfo(const Record &R, std::stringstream &OS) { static void emitArgInfo(const Record &R, std::stringstream &OS) {
// This function will count the number of arguments specified for the // This function will count the number of arguments specified for the
// attribute and emit the number of required arguments followed by the // attribute and emit the number of required arguments followed by the
// number of optional arguments. // number of optional arguments.
std::vector<Record *> Args = R.getValueAsListOfDefs("Args"); std::vector<Record *> Args = R.getValueAsListOfDefs("Args");
unsigned ArgCount = 0, OptCount = 0; unsigned ArgCount = 0, OptCount = 0;
bool HasVariadic = false; bool HasVariadic = false;
for (const auto *Arg : Args) { for (const auto *Arg : Args) {
// If the arg is fake, it's the user's job to supply it: general parsing
// logic shouldn't need to know anything about it.
if (Arg->getValueAsBit("Fake"))
continue;
Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount; Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount;
if (!HasVariadic && isArgVariadic(*Arg, R.getName())) if (!HasVariadic && isArgVariadic(*Arg, R.getName()))
HasVariadic = true; HasVariadic = true;
} }
// If there is a variadic argument, we will set the optional argument count // If there is a variadic argument, we will set the optional argument count
// to its largest value. Since it's currently a 4-bit number, we set it to 15. // to its largest value. Since it's currently a 4-bit number, we set it to 15.
OS << ArgCount << ", " << (HasVariadic ? 15 : OptCount); OS << ArgCount << ", " << (HasVariadic ? 15 : OptCount);
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Linesstatic std::string GetSubjectWithSuffix(const Record *R) {
const std::string &B = R->getName(); const std::string &B = R->getName();
if (B == "DeclBase") if (B == "DeclBase")
return "Decl"; return "Decl";
return B + "Decl"; return B + "Decl";
} }
static std::string GenerateCustomAppertainsTo(const Record &Subject, static std::string GenerateCustomAppertainsTo(const Record &Subject,
raw_ostream &OS) { raw_ostream &OS) {
std::string FnName = "is" + Subject.getName(); std::string FnName = "is" + Subject.getName().str();
// If this code has already been generated, simply return the previous // If this code has already been generated, simply return the previous
// instance of it. // instance of it.
static std::set<std::string> CustomSubjectSet; static std::set<std::string> CustomSubjectSet;
auto I = CustomSubjectSet.find(FnName); auto I = CustomSubjectSet.find(FnName);
if (I != CustomSubjectSet.end()) if (I != CustomSubjectSet.end())
return *I; return *I;
Show All 32 Linesstatic std::string GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
if (Subjects.empty()) if (Subjects.empty())
return "defaultAppertainsTo"; return "defaultAppertainsTo";
bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn"); bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn");
// Otherwise, generate an appertainsTo check specific to this attribute which // Otherwise, generate an appertainsTo check specific to this attribute which
// checks all of the given subjects against the Decl passed in. Return the // checks all of the given subjects against the Decl passed in. Return the
// name of that check to the caller. // name of that check to the caller.
std::string FnName = "check" + Attr.getName() + "AppertainsTo"; std::string FnName = "check" + Attr.getName().str() + "AppertainsTo";
std::stringstream SS; std::stringstream SS;
SS << "static bool " << FnName << "(Sema &S, const AttributeList &Attr, "; SS << "static bool " << FnName << "(Sema &S, const AttributeList &Attr, ";
SS << "const Decl *D) {\n"; SS << "const Decl *D) {\n";
SS << " if ("; SS << " if (";
for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) { for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
// If the subject has custom code associated with it, generate a function // If the subject has custom code associated with it, generate a function
// for it. The function cannot be inlined into this check (yet) because it // for it. The function cannot be inlined into this check (yet) because it
// requires the subject to be of a specific type, and were that information // requires the subject to be of a specific type, and were that information
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Linesstatic std::string GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
// If there are zero or one spellings, or all of the spellings share the same // If there are zero or one spellings, or all of the spellings share the same
// name, we can also bail out early. // name, we can also bail out early.
if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings)) if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings))
return "defaultSpellingIndexToSemanticSpelling"; return "defaultSpellingIndexToSemanticSpelling";
// Generate the enumeration we will use for the mapping. // Generate the enumeration we will use for the mapping.
SemanticSpellingMap SemanticToSyntacticMap; SemanticSpellingMap SemanticToSyntacticMap;
std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap); std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
std::string Name = Attr.getName() + "AttrSpellingMap"; std::string Name = Attr.getName().str() + "AttrSpellingMap";
OS << "static unsigned " << Name << "(const AttributeList &Attr) {\n"; OS << "static unsigned " << Name << "(const AttributeList &Attr) {\n";
OS << Enum; OS << Enum;
OS << " unsigned Idx = Attr.getAttributeSpellingListIndex();\n"; OS << " unsigned Idx = Attr.getAttributeSpellingListIndex();\n";
WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS); WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS);
OS << "}\n\n"; OS << "}\n\n";
return Name; return Name;
▲ Show 20 Lines • Show All 393 Lines • Show Last 20 Lines

utils/TableGen/NeonEmitter.cpp

Show First 20 Lines • Show All 1,472 Lines • ▼ Show 20 Linesstd::pair<Type, std::string> Intrinsic::DagEmitter::emitDag(DagInit *DI) {
return std::make_pair(Type::getVoid(), ""); return std::make_pair(Type::getVoid(), "");
} }
std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagOp(DagInit *DI) { std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagOp(DagInit *DI) {
std::string Op = cast<StringInit>(DI->getArg(0))->getAsUnquotedString(); std::string Op = cast<StringInit>(DI->getArg(0))->getAsUnquotedString();
if (DI->getNumArgs() == 2) { if (DI->getNumArgs() == 2) {
// Unary op. // Unary op.
std::pair<Type, std::string> R = std::pair<Type, std::string> R =
emitDagArg(DI->getArg(1), DI->getArgName(1)); emitDagArg(DI->getArg(1), DI->getArgNameStr(1));
return std::make_pair(R.first, Op + R.second); return std::make_pair(R.first, Op + R.second);
} else { } else {
assert(DI->getNumArgs() == 3 && "Can only handle unary and binary ops!"); assert(DI->getNumArgs() == 3 && "Can only handle unary and binary ops!");
std::pair<Type, std::string> R1 = std::pair<Type, std::string> R1 =
emitDagArg(DI->getArg(1), DI->getArgName(1)); emitDagArg(DI->getArg(1), DI->getArgNameStr(1));
std::pair<Type, std::string> R2 = std::pair<Type, std::string> R2 =
emitDagArg(DI->getArg(2), DI->getArgName(2)); emitDagArg(DI->getArg(2), DI->getArgNameStr(2));
assert_with_loc(R1.first == R2.first, "Argument type mismatch!"); assert_with_loc(R1.first == R2.first, "Argument type mismatch!");
return std::make_pair(R1.first, R1.second + " " + Op + " " + R2.second); return std::make_pair(R1.first, R1.second + " " + Op + " " + R2.second);
} }
} }
std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagCall(DagInit *DI) { std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagCall(DagInit *DI) {
std::vector<Type> Types; std::vector<Type> Types;
std::vector<std::string> Values; std::vector<std::string> Values;
for (unsigned I = 0; I < DI->getNumArgs() - 1; ++I) { for (unsigned I = 0; I < DI->getNumArgs() - 1; ++I) {
std::pair<Type, std::string> R = std::pair<Type, std::string> R =
emitDagArg(DI->getArg(I + 1), DI->getArgName(I + 1)); emitDagArg(DI->getArg(I + 1), DI->getArgNameStr(I + 1));
Types.push_back(R.first); Types.push_back(R.first);
Values.push_back(R.second); Values.push_back(R.second);
} }
// Look up the called intrinsic. // Look up the called intrinsic.
std::string N; std::string N;
if (StringInit *SI = dyn_cast<StringInit>(DI->getArg(0))) if (StringInit *SI = dyn_cast<StringInit>(DI->getArg(0)))
N = SI->getAsUnquotedString(); N = SI->getAsUnquotedString();
Show All 16 Linesstd::pair<Type, std::string> Intrinsic::DagEmitter::emitDagCall(DagInit *DI) {
return std::make_pair(Callee.getReturnType(), S); return std::make_pair(Callee.getReturnType(), S);
} }
std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagCast(DagInit *DI, std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagCast(DagInit *DI,
bool IsBitCast){ bool IsBitCast){
// (cast MOD* VAL) -> cast VAL to type given by MOD. // (cast MOD* VAL) -> cast VAL to type given by MOD.
std::pair<Type, std::string> R = emitDagArg( std::pair<Type, std::string> R = emitDagArg(
DI->getArg(DI->getNumArgs() - 1), DI->getArgName(DI->getNumArgs() - 1)); DI->getArg(DI->getNumArgs() - 1),
DI->getArgNameStr(DI->getNumArgs() - 1));
Type castToType = R.first; Type castToType = R.first;
for (unsigned ArgIdx = 0; ArgIdx < DI->getNumArgs() - 1; ++ArgIdx) { for (unsigned ArgIdx = 0; ArgIdx < DI->getNumArgs() - 1; ++ArgIdx) {
// MOD can take several forms: // MOD can take several forms:
// 1. $X - take the type of parameter / variable X. // 1. $X - take the type of parameter / variable X.
// 2. The value "R" - take the type of the return type. // 2. The value "R" - take the type of the return type.
// 3. a type string // 3. a type string
// 4. The value "U" or "S" to switch the signedness. // 4. The value "U" or "S" to switch the signedness.
// 5. The value "H" or "D" to half or double the bitwidth. // 5. The value "H" or "D" to half or double the bitwidth.
// 6. The value "8" to convert to 8-bit (signed) integer lanes. // 6. The value "8" to convert to 8-bit (signed) integer lanes.
if (!DI->getArgName(ArgIdx).empty()) { if (!DI->getArgNameStr(ArgIdx).empty()) {
assert_with_loc(Intr.Variables.find(DI->getArgName(ArgIdx)) != assert_with_loc(Intr.Variables.find(DI->getArgNameStr(ArgIdx)) !=
Intr.Variables.end(), Intr.Variables.end(),
"Variable not found"); "Variable not found");
castToType = Intr.Variables[DI->getArgName(ArgIdx)].getType(); castToType = Intr.Variables[DI->getArgNameStr(ArgIdx)].getType();
} else { } else {
StringInit *SI = dyn_cast<StringInit>(DI->getArg(ArgIdx)); StringInit *SI = dyn_cast<StringInit>(DI->getArg(ArgIdx));
assert_with_loc(SI, "Expected string type or $Name for cast type"); assert_with_loc(SI, "Expected string type or $Name for cast type");
if (SI->getAsUnquotedString() == "R") { if (SI->getAsUnquotedString() == "R") {
castToType = Intr.getReturnType(); castToType = Intr.getReturnType();
} else if (SI->getAsUnquotedString() == "U") { } else if (SI->getAsUnquotedString() == "U") {
castToType.makeUnsigned(); castToType.makeUnsigned();
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines void expand(SetTheory &ST, Record *R, SetTheory::RecSet &Elts) override {
return; return;
for (unsigned I = 0; I < N; ++I) for (unsigned I = 0; I < N; ++I)
Elts.insert(R->getRecords().getDef("sv" + utostr(I + Addend))); Elts.insert(R->getRecords().getDef("sv" + utostr(I + Addend)));
} }
}; };
// (shuffle arg1, arg2, sequence) // (shuffle arg1, arg2, sequence)
std::pair<Type, std::string> Arg1 = std::pair<Type, std::string> Arg1 =
emitDagArg(DI->getArg(0), DI->getArgName(0)); emitDagArg(DI->getArg(0), DI->getArgNameStr(0));
std::pair<Type, std::string> Arg2 = std::pair<Type, std::string> Arg2 =
emitDagArg(DI->getArg(1), DI->getArgName(1)); emitDagArg(DI->getArg(1), DI->getArgNameStr(1));
assert_with_loc(Arg1.first == Arg2.first, assert_with_loc(Arg1.first == Arg2.first,
"Different types in arguments to shuffle!"); "Different types in arguments to shuffle!");
SetTheory ST; SetTheory ST;
SetTheory::RecSet Elts; SetTheory::RecSet Elts;
ST.addOperator("lowhalf", llvm::make_unique<LowHalf>()); ST.addOperator("lowhalf", llvm::make_unique<LowHalf>());
ST.addOperator("highhalf", llvm::make_unique<HighHalf>()); ST.addOperator("highhalf", llvm::make_unique<HighHalf>());
ST.addOperator("rev", ST.addOperator("rev",
Show All 25 Lines if (Elts.size() > T.getNumElements()) {
T.halveLanes(); T.halveLanes();
} }
return std::make_pair(T, S); return std::make_pair(T, S);
} }
std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagDup(DagInit *DI) { std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagDup(DagInit *DI) {
assert_with_loc(DI->getNumArgs() == 1, "dup() expects one argument"); assert_with_loc(DI->getNumArgs() == 1, "dup() expects one argument");
std::pair<Type, std::string> A = emitDagArg(DI->getArg(0), DI->getArgName(0)); std::pair<Type, std::string> A = emitDagArg(DI->getArg(0),
DI->getArgNameStr(0));
assert_with_loc(A.first.isScalar(), "dup() expects a scalar argument"); assert_with_loc(A.first.isScalar(), "dup() expects a scalar argument");
Type T = Intr.getBaseType(); Type T = Intr.getBaseType();
assert_with_loc(T.isVector(), "dup() used but default type is scalar!"); assert_with_loc(T.isVector(), "dup() used but default type is scalar!");
std::string S = "(" + T.str() + ") {"; std::string S = "(" + T.str() + ") {";
for (unsigned I = 0; I < T.getNumElements(); ++I) { for (unsigned I = 0; I < T.getNumElements(); ++I) {
if (I != 0) if (I != 0)
S += ", "; S += ", ";
S += A.second; S += A.second;
} }
S += "}"; S += "}";
return std::make_pair(T, S); return std::make_pair(T, S);
} }
std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagSplat(DagInit *DI) { std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagSplat(DagInit *DI) {
assert_with_loc(DI->getNumArgs() == 2, "splat() expects two arguments"); assert_with_loc(DI->getNumArgs() == 2, "splat() expects two arguments");
std::pair<Type, std::string> A = emitDagArg(DI->getArg(0), DI->getArgName(0)); std::pair<Type, std::string> A = emitDagArg(DI->getArg(0),
std::pair<Type, std::string> B = emitDagArg(DI->getArg(1), DI->getArgName(1)); DI->getArgNameStr(0));
std::pair<Type, std::string> B = emitDagArg(DI->getArg(1),
DI->getArgNameStr(1));
assert_with_loc(B.first.isScalar(), assert_with_loc(B.first.isScalar(),
"splat() requires a scalar int as the second argument"); "splat() requires a scalar int as the second argument");
std::string S = "__builtin_shufflevector(" + A.second + ", " + A.second; std::string S = "__builtin_shufflevector(" + A.second + ", " + A.second;
for (unsigned I = 0; I < Intr.getBaseType().getNumElements(); ++I) { for (unsigned I = 0; I < Intr.getBaseType().getNumElements(); ++I) {
S += ", " + B.second; S += ", " + B.second;
} }
S += ")"; S += ")";
return std::make_pair(Intr.getBaseType(), S); return std::make_pair(Intr.getBaseType(), S);
} }
std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagSaveTemp(DagInit *DI) { std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagSaveTemp(DagInit *DI) {
assert_with_loc(DI->getNumArgs() == 2, "save_temp() expects two arguments"); assert_with_loc(DI->getNumArgs() == 2, "save_temp() expects two arguments");
std::pair<Type, std::string> A = emitDagArg(DI->getArg(1), DI->getArgName(1)); std::pair<Type, std::string> A = emitDagArg(DI->getArg(1),
DI->getArgNameStr(1));
assert_with_loc(!A.first.isVoid(), assert_with_loc(!A.first.isVoid(),
"Argument to save_temp() must have non-void type!"); "Argument to save_temp() must have non-void type!");
std::string N = DI->getArgName(0); std::string N = DI->getArgNameStr(0);
assert_with_loc(!N.empty(), assert_with_loc(!N.empty(),
"save_temp() expects a name as the first argument"); "save_temp() expects a name as the first argument");
assert_with_loc(Intr.Variables.find(N) == Intr.Variables.end(), assert_with_loc(Intr.Variables.find(N) == Intr.Variables.end(),
"Variable already defined!"); "Variable already defined!");
Intr.Variables[N] = Variable(A.first, N + Intr.VariablePostfix); Intr.Variables[N] = Variable(A.first, N + Intr.VariablePostfix);
std::string S = std::string S =
▲ Show 20 Lines • Show All 674 Lines • Show Last 20 Lines

www/cxx_dr_status.html

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 807 Lines • ▼ Show 20 Lines <tr id="128">
<td>TC1</td> <td>TC1</td>
<td>Casting between enum types</td> <td>Casting between enum types</td>
<td class="full" align="center">Yes</td> <td class="full" align="center">Yes</td>
</tr> </tr>
<tr id="129"> <tr id="129">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#129">129</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#129">129</a></td>
<td>CD3</td> <td>CD3</td>
<td>Stability of uninitialized auto variables</td> <td>Stability of uninitialized auto variables</td>
<td class="none" align="center">Duplicate of <a href="#616">616</a></td> <td class="svn" align="center">Duplicate of <a href="#616">616</a></td>
</tr> </tr>
<tr id="130"> <tr id="130">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#130">130</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#130">130</a></td>
<td>NAD</td> <td>NAD</td>
<td>Sequence points and <I>new-expression</I>s</td> <td>Sequence points and <I>new-expression</I>s</td>
<td class="na" align="center">N/A</td> <td class="na" align="center">N/A</td>
</tr> </tr>
<tr id="131"> <tr id="131">
▲ Show 20 Lines • Show All 650 Lines • ▼ Show 20 Lines <tr id="239">
<td>CD1</td> <td>CD1</td>
<td>Footnote 116 and Koenig lookup</td> <td>Footnote 116 and Koenig lookup</td>
<td class="full" align="center">Yes</td> <td class="full" align="center">Yes</td>
</tr> </tr>
<tr id="240"> <tr id="240">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#240">240</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#240">240</a></td>
<td>CD3</td> <td>CD3</td>
<td>Uninitialized values and undefined behavior</td> <td>Uninitialized values and undefined behavior</td>
<td class="none" align="center">Duplicate of <a href="#616">616</a></td> <td class="svn" align="center">Duplicate of <a href="#616">616</a></td>
</tr> </tr>
<tr id="241"> <tr id="241">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#241">241</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#241">241</a></td>
<td>TC1</td> <td>TC1</td>
<td>Error in example in 14.8.1</td> <td>Error in example in 14.8.1</td>
<td class="full" align="center">Yes</td> <td class="full" align="center">Yes</td>
</tr> </tr>
<tr id="242"> <tr id="242">
▲ Show 20 Lines • Show All 416 Lines • ▼ Show 20 Lines <tr id="311">
<td>NAD</td> <td>NAD</td>
<td>Using qualified name to reopen nested namespace</td> <td>Using qualified name to reopen nested namespace</td>
<td class="full" align="center">Yes</td> <td class="full" align="center">Yes</td>
</tr> </tr>
<tr id="312"> <tr id="312">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#312">312</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#312">312</a></td>
<td>CD3</td> <td>CD3</td>
<td>&#8220;use&#8221; of invalid pointer value not defined</td> <td>&#8220;use&#8221; of invalid pointer value not defined</td>
<td class="none" align="center">Duplicate of <a href="#616">616</a></td> <td class="svn" align="center">Duplicate of <a href="#616">616</a></td>
</tr> </tr>
<tr id="313"> <tr id="313">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#313">313</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#313">313</a></td>
<td>dup</td> <td>dup</td>
<td>Class with single conversion function to integral as array size in <TT>new</TT></td> <td>Class with single conversion function to integral as array size in <TT>new</TT></td>
<td class="full" align="center">Duplicate of <a href="#299">299</a> (C++11 onwards)</td> <td class="full" align="center">Duplicate of <a href="#299">299</a> (C++11 onwards)</td>
</tr> </tr>
<tr class="open" id="314"> <tr class="open" id="314">
▲ Show 20 Lines • Show All 1,809 Lines • ▼ Show 20 Lines <tr id="615">
<td>C++11</td> <td>C++11</td>
<td>Incorrect description of variables that can be initialized</td> <td>Incorrect description of variables that can be initialized</td>
<td class="full" align="center">Yes</td> <td class="full" align="center">Yes</td>
</tr> </tr>
<tr id="616"> <tr id="616">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#616">616</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#616">616</a></td>
<td>CD3</td> <td>CD3</td>
<td>Definition of &#8220;indeterminate value&#8221;</td> <td>Definition of &#8220;indeterminate value&#8221;</td>
<td class="none" align="center">No</td> <td class="svn" align="center">SVN</td>
</tr> </tr>
<tr class="open" id="617"> <tr class="open" id="617">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#617">617</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#617">617</a></td>
<td>drafting</td> <td>drafting</td>
<td>Lvalue-to-rvalue conversions of uninitialized <TT>char</TT> objects</td> <td>Lvalue-to-rvalue conversions of uninitialized <TT>char</TT> objects</td>
<td align="center">Not resolved</td> <td align="center">Not resolved</td>
</tr> </tr>
<tr id="618"> <tr id="618">
▲ Show 20 Lines • Show All 3,337 Lines • ▼ Show 20 Lines <tr id="1212">
<td>C++11</td> <td>C++11</td>
<td>Non-function-call xvalues and <TT>decltype</TT></td> <td>Non-function-call xvalues and <TT>decltype</TT></td>
<td class="none" align="center">Unknown</td> <td class="none" align="center">Unknown</td>
</tr> </tr>
<tr id="1213"> <tr id="1213">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1213">1213</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1213">1213</a></td>
<td>CD3</td> <td>CD3</td>
<td>Array subscripting and xvalues</td> <td>Array subscripting and xvalues</td>
<td class="none" align="center">Unknown</td> <td class="svn" align="center">SVN</td>
</tr> </tr>
<tr id="1214"> <tr id="1214">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1214">1214</a></td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1214">1214</a></td>
<td>C++11</td> <td>C++11</td>
<td>Kinds of initializers</td> <td>Kinds of initializers</td>
<td class="none" align="center">Unknown</td> <td class="none" align="center">Unknown</td>
</tr> </tr>
<tr id="1215"> <tr id="1215">
▲ Show 20 Lines • Show All 5,836 Lines • Show Last 20 Lines
test/Analysis/explain-svals.cpp