mirror of
https://github.com/github/codeql.git
synced 2025-12-16 16:53:25 +01:00
JS: Update TRAP after extractor change
This commit is contained in:
File diff suppressed because it is too large
Load Diff
@@ -50,61 +50,64 @@ toplevels(#20001,0)
|
||||
#20016=@"loc,{#10000},1,1,2,0"
|
||||
locations_default(#20016,#10000,1,1,2,0)
|
||||
hasLocation(#20001,#20016)
|
||||
#20017=*
|
||||
stmts(#20017,26,#20001,0,"declare class C {}")
|
||||
hasLocation(#20017,#20003)
|
||||
stmt_containers(#20017,#20001)
|
||||
has_declare_keyword(#20017)
|
||||
#20018=*
|
||||
exprs(#20018,78,#20017,0,"C")
|
||||
hasLocation(#20018,#20009)
|
||||
enclosing_stmt(#20018,#20017)
|
||||
expr_containers(#20018,#20001)
|
||||
literals("C","C",#20018)
|
||||
#20019=@"var;{C};{#20000}"
|
||||
variables(#20019,"C",#20000)
|
||||
decl(#20018,#20019)
|
||||
#20017=@"var;{C};{#20000}"
|
||||
variables(#20017,"C",#20000)
|
||||
#20018=@"local_type_name;{C};{#20000}"
|
||||
local_type_names(#20018,"C",#20000)
|
||||
#20019=*
|
||||
stmts(#20019,26,#20001,0,"declare class C {}")
|
||||
hasLocation(#20019,#20003)
|
||||
stmt_containers(#20019,#20001)
|
||||
has_declare_keyword(#20019)
|
||||
#20020=*
|
||||
scopes(#20020,10)
|
||||
scopenodes(#20017,#20020)
|
||||
scopenesting(#20020,#20000)
|
||||
exprs(#20020,78,#20019,0,"C")
|
||||
hasLocation(#20020,#20009)
|
||||
enclosing_stmt(#20020,#20019)
|
||||
expr_containers(#20020,#20001)
|
||||
literals("C","C",#20020)
|
||||
decl(#20020,#20017)
|
||||
typedecl(#20020,#20018)
|
||||
#20021=*
|
||||
properties(#20021,#20017,2,0,"constructor() {}")
|
||||
#20022=@"loc,{#10000},1,17,1,16"
|
||||
locations_default(#20022,#10000,1,17,1,16)
|
||||
hasLocation(#20021,#20022)
|
||||
#20023=*
|
||||
exprs(#20023,0,#20021,0,"constructor")
|
||||
hasLocation(#20023,#20022)
|
||||
enclosing_stmt(#20023,#20017)
|
||||
expr_containers(#20023,#20001)
|
||||
literals("constructor","constructor",#20023)
|
||||
scopes(#20021,10)
|
||||
scopenodes(#20019,#20021)
|
||||
scopenesting(#20021,#20000)
|
||||
#20022=*
|
||||
properties(#20022,#20019,2,0,"constructor() {}")
|
||||
#20023=@"loc,{#10000},1,17,1,16"
|
||||
locations_default(#20023,#10000,1,17,1,16)
|
||||
hasLocation(#20022,#20023)
|
||||
#20024=*
|
||||
exprs(#20024,9,#20021,1,"() {}")
|
||||
hasLocation(#20024,#20022)
|
||||
enclosing_stmt(#20024,#20017)
|
||||
exprs(#20024,0,#20022,0,"constructor")
|
||||
hasLocation(#20024,#20023)
|
||||
enclosing_stmt(#20024,#20019)
|
||||
expr_containers(#20024,#20001)
|
||||
literals("constructor","constructor",#20024)
|
||||
#20025=*
|
||||
scopes(#20025,1)
|
||||
scopenodes(#20024,#20025)
|
||||
scopenesting(#20025,#20020)
|
||||
#20026=@"var;{arguments};{#20025}"
|
||||
variables(#20026,"arguments",#20025)
|
||||
is_arguments_object(#20026)
|
||||
#20027=*
|
||||
stmts(#20027,1,#20024,-2,"{}")
|
||||
hasLocation(#20027,#20022)
|
||||
stmt_containers(#20027,#20024)
|
||||
is_method(#20021)
|
||||
exprs(#20025,9,#20022,1,"() {}")
|
||||
hasLocation(#20025,#20023)
|
||||
enclosing_stmt(#20025,#20019)
|
||||
expr_containers(#20025,#20001)
|
||||
#20026=*
|
||||
scopes(#20026,1)
|
||||
scopenodes(#20025,#20026)
|
||||
scopenesting(#20026,#20021)
|
||||
#20027=@"var;{arguments};{#20026}"
|
||||
variables(#20027,"arguments",#20026)
|
||||
is_arguments_object(#20027)
|
||||
#20028=*
|
||||
entry_cfg_node(#20028,#20001)
|
||||
#20029=@"loc,{#10000},1,1,1,0"
|
||||
locations_default(#20029,#10000,1,1,1,0)
|
||||
hasLocation(#20028,#20029)
|
||||
#20030=*
|
||||
exit_cfg_node(#20030,#20001)
|
||||
hasLocation(#20030,#20015)
|
||||
successor(#20017,#20030)
|
||||
successor(#20028,#20017)
|
||||
stmts(#20028,1,#20025,-2,"{}")
|
||||
hasLocation(#20028,#20023)
|
||||
stmt_containers(#20028,#20025)
|
||||
is_method(#20022)
|
||||
#20029=*
|
||||
entry_cfg_node(#20029,#20001)
|
||||
#20030=@"loc,{#10000},1,1,1,0"
|
||||
locations_default(#20030,#10000,1,1,1,0)
|
||||
hasLocation(#20029,#20030)
|
||||
#20031=*
|
||||
exit_cfg_node(#20031,#20001)
|
||||
hasLocation(#20031,#20015)
|
||||
successor(#20019,#20031)
|
||||
successor(#20029,#20019)
|
||||
numlines(#10000,1,1,0)
|
||||
filetype(#10000,"typescript")
|
||||
|
||||
@@ -584,62 +584,63 @@ toplevels(#20001,0)
|
||||
#20221=@"loc,{#10000},1,1,16,0"
|
||||
locations_default(#20221,#10000,1,1,16,0)
|
||||
hasLocation(#20001,#20221)
|
||||
#20222=@"var;{C};{#20000}"
|
||||
variables(#20222,"C",#20000)
|
||||
#20223=@"local_type_name;{C};{#20000}"
|
||||
local_type_names(#20223,"C",#20000)
|
||||
#20224=*
|
||||
stmts(#20224,18,#20001,0,"declare var A : any;")
|
||||
hasLocation(#20224,#20003)
|
||||
stmt_containers(#20224,#20001)
|
||||
has_declare_keyword(#20224)
|
||||
#20225=*
|
||||
exprs(#20225,64,#20224,0,"A : any")
|
||||
#20226=@"loc,{#10000},1,13,1,19"
|
||||
locations_default(#20226,#10000,1,13,1,19)
|
||||
hasLocation(#20225,#20226)
|
||||
enclosing_stmt(#20225,#20224)
|
||||
expr_containers(#20225,#20001)
|
||||
#20222=@"var;{A};{#20000}"
|
||||
variables(#20222,"A",#20000)
|
||||
#20223=@"var;{B};{#20000}"
|
||||
variables(#20223,"B",#20000)
|
||||
#20224=@"var;{C};{#20000}"
|
||||
variables(#20224,"C",#20000)
|
||||
variables(#20224,"C",#20000)
|
||||
#20225=@"local_type_name;{C};{#20000}"
|
||||
local_type_names(#20225,"C",#20000)
|
||||
#20226=*
|
||||
stmts(#20226,18,#20001,0,"declare var A : any;")
|
||||
hasLocation(#20226,#20003)
|
||||
stmt_containers(#20226,#20001)
|
||||
has_declare_keyword(#20226)
|
||||
#20227=*
|
||||
exprs(#20227,78,#20225,0,"A")
|
||||
hasLocation(#20227,#20037)
|
||||
enclosing_stmt(#20227,#20224)
|
||||
exprs(#20227,64,#20226,0,"A : any")
|
||||
#20228=@"loc,{#10000},1,13,1,19"
|
||||
locations_default(#20228,#10000,1,13,1,19)
|
||||
hasLocation(#20227,#20228)
|
||||
enclosing_stmt(#20227,#20226)
|
||||
expr_containers(#20227,#20001)
|
||||
literals("A","A",#20227)
|
||||
#20228=@"var;{A};{#20000}"
|
||||
variables(#20228,"A",#20000)
|
||||
decl(#20227,#20228)
|
||||
#20229=*
|
||||
typeexprs(#20229,2,#20225,2,"any")
|
||||
hasLocation(#20229,#20041)
|
||||
enclosing_stmt(#20229,#20224)
|
||||
exprs(#20229,78,#20227,0,"A")
|
||||
hasLocation(#20229,#20037)
|
||||
enclosing_stmt(#20229,#20226)
|
||||
expr_containers(#20229,#20001)
|
||||
literals("any","any",#20229)
|
||||
literals("A","A",#20229)
|
||||
decl(#20229,#20222)
|
||||
#20230=*
|
||||
stmts(#20230,18,#20001,1,"declare var B : any;")
|
||||
hasLocation(#20230,#20005)
|
||||
stmt_containers(#20230,#20001)
|
||||
has_declare_keyword(#20230)
|
||||
typeexprs(#20230,2,#20227,2,"any")
|
||||
hasLocation(#20230,#20041)
|
||||
enclosing_stmt(#20230,#20226)
|
||||
expr_containers(#20230,#20001)
|
||||
literals("any","any",#20230)
|
||||
#20231=*
|
||||
exprs(#20231,64,#20230,0,"B : any")
|
||||
#20232=@"loc,{#10000},2,13,2,19"
|
||||
locations_default(#20232,#10000,2,13,2,19)
|
||||
hasLocation(#20231,#20232)
|
||||
enclosing_stmt(#20231,#20230)
|
||||
expr_containers(#20231,#20001)
|
||||
#20233=*
|
||||
exprs(#20233,78,#20231,0,"B")
|
||||
hasLocation(#20233,#20049)
|
||||
enclosing_stmt(#20233,#20230)
|
||||
expr_containers(#20233,#20001)
|
||||
literals("B","B",#20233)
|
||||
#20234=@"var;{B};{#20000}"
|
||||
variables(#20234,"B",#20000)
|
||||
decl(#20233,#20234)
|
||||
stmts(#20231,18,#20001,1,"declare var B : any;")
|
||||
hasLocation(#20231,#20005)
|
||||
stmt_containers(#20231,#20001)
|
||||
has_declare_keyword(#20231)
|
||||
#20232=*
|
||||
exprs(#20232,64,#20231,0,"B : any")
|
||||
#20233=@"loc,{#10000},2,13,2,19"
|
||||
locations_default(#20233,#10000,2,13,2,19)
|
||||
hasLocation(#20232,#20233)
|
||||
enclosing_stmt(#20232,#20231)
|
||||
expr_containers(#20232,#20001)
|
||||
#20234=*
|
||||
exprs(#20234,78,#20232,0,"B")
|
||||
hasLocation(#20234,#20049)
|
||||
enclosing_stmt(#20234,#20231)
|
||||
expr_containers(#20234,#20001)
|
||||
literals("B","B",#20234)
|
||||
decl(#20234,#20223)
|
||||
#20235=*
|
||||
typeexprs(#20235,2,#20231,2,"any")
|
||||
typeexprs(#20235,2,#20232,2,"any")
|
||||
hasLocation(#20235,#20053)
|
||||
enclosing_stmt(#20235,#20230)
|
||||
enclosing_stmt(#20235,#20231)
|
||||
expr_containers(#20235,#20001)
|
||||
literals("any","any",#20235)
|
||||
#20236=*
|
||||
@@ -660,7 +661,7 @@ hasLocation(#20239,#20061)
|
||||
enclosing_stmt(#20239,#20236)
|
||||
expr_containers(#20239,#20001)
|
||||
literals("C","C",#20239)
|
||||
decl(#20239,#20222)
|
||||
decl(#20239,#20224)
|
||||
#20240=*
|
||||
typeexprs(#20240,2,#20237,2,"any")
|
||||
hasLocation(#20240,#20065)
|
||||
@@ -679,8 +680,8 @@ hasLocation(#20243,#20071)
|
||||
enclosing_stmt(#20243,#20241)
|
||||
expr_containers(#20243,#20001)
|
||||
literals("C","C",#20243)
|
||||
decl(#20243,#20222)
|
||||
typedecl(#20243,#20223)
|
||||
decl(#20243,#20224)
|
||||
typedecl(#20243,#20225)
|
||||
#20244=*
|
||||
scopes(#20244,10)
|
||||
scopenodes(#20241,#20244)
|
||||
@@ -769,7 +770,7 @@ exprs(#20266,79,#20265,0,"A")
|
||||
hasLocation(#20266,#20093)
|
||||
expr_containers(#20266,#20258)
|
||||
literals("A","A",#20266)
|
||||
bind(#20266,#20228)
|
||||
bind(#20266,#20222)
|
||||
#20267=*
|
||||
stmts(#20267,1,#20258,-2,"{}")
|
||||
#20268=@"loc,{#10000},7,12,7,13"
|
||||
@@ -825,7 +826,7 @@ exprs(#20281,79,#20279,0,"A")
|
||||
hasLocation(#20281,#20109)
|
||||
expr_containers(#20281,#20272)
|
||||
literals("A","A",#20281)
|
||||
bind(#20281,#20228)
|
||||
bind(#20281,#20222)
|
||||
#20282=*
|
||||
exprs(#20282,94,#20277,1,"@B")
|
||||
#20283=@"loc,{#10000},8,9,8,10"
|
||||
@@ -837,7 +838,7 @@ exprs(#20284,79,#20282,0,"B")
|
||||
hasLocation(#20284,#20113)
|
||||
expr_containers(#20284,#20272)
|
||||
literals("B","B",#20284)
|
||||
bind(#20284,#20234)
|
||||
bind(#20284,#20223)
|
||||
#20285=*
|
||||
stmts(#20285,1,#20272,-2,"{}")
|
||||
#20286=@"loc,{#10000},8,16,8,17"
|
||||
@@ -899,7 +900,7 @@ exprs(#20300,79,#20299,0,"A")
|
||||
hasLocation(#20300,#20133)
|
||||
expr_containers(#20300,#20290)
|
||||
literals("A","A",#20300)
|
||||
bind(#20300,#20228)
|
||||
bind(#20300,#20222)
|
||||
#20301=*
|
||||
stmts(#20301,1,#20290,-2,"{}")
|
||||
#20302=@"loc,{#10000},10,18,10,19"
|
||||
@@ -963,7 +964,7 @@ exprs(#20317,79,#20315,0,"A")
|
||||
hasLocation(#20317,#20153)
|
||||
expr_containers(#20317,#20306)
|
||||
literals("A","A",#20317)
|
||||
bind(#20317,#20228)
|
||||
bind(#20317,#20222)
|
||||
#20318=*
|
||||
exprs(#20318,94,#20313,1,"@B")
|
||||
#20319=@"loc,{#10000},11,15,11,16"
|
||||
@@ -975,7 +976,7 @@ exprs(#20320,79,#20318,0,"B")
|
||||
hasLocation(#20320,#20157)
|
||||
expr_containers(#20320,#20306)
|
||||
literals("B","B",#20320)
|
||||
bind(#20320,#20234)
|
||||
bind(#20320,#20223)
|
||||
#20321=*
|
||||
stmts(#20321,1,#20306,-2,"{}")
|
||||
#20322=@"loc,{#10000},11,22,11,23"
|
||||
@@ -1037,7 +1038,7 @@ exprs(#20336,79,#20335,0,"A")
|
||||
hasLocation(#20336,#20173)
|
||||
expr_containers(#20336,#20326)
|
||||
literals("A","A",#20336)
|
||||
bind(#20336,#20228)
|
||||
bind(#20336,#20222)
|
||||
#20337=*
|
||||
exprs(#20337,104,#20326,-12,"@B")
|
||||
#20338=@"loc,{#10000},13,12,13,13"
|
||||
@@ -1053,7 +1054,7 @@ exprs(#20340,79,#20339,0,"B")
|
||||
hasLocation(#20340,#20181)
|
||||
expr_containers(#20340,#20326)
|
||||
literals("B","B",#20340)
|
||||
bind(#20340,#20234)
|
||||
bind(#20340,#20223)
|
||||
#20341=*
|
||||
stmts(#20341,1,#20326,-2,"{}")
|
||||
#20342=@"loc,{#10000},13,18,13,19"
|
||||
@@ -1115,7 +1116,7 @@ exprs(#20356,79,#20355,0,"A")
|
||||
hasLocation(#20356,#20197)
|
||||
expr_containers(#20356,#20346)
|
||||
literals("A","A",#20356)
|
||||
bind(#20356,#20228)
|
||||
bind(#20356,#20222)
|
||||
#20357=*
|
||||
exprs(#20357,104,#20346,-12,"@B @C")
|
||||
#20358=@"loc,{#10000},14,12,14,16"
|
||||
@@ -1133,7 +1134,7 @@ exprs(#20361,79,#20359,0,"B")
|
||||
hasLocation(#20361,#20205)
|
||||
expr_containers(#20361,#20346)
|
||||
literals("B","B",#20361)
|
||||
bind(#20361,#20234)
|
||||
bind(#20361,#20223)
|
||||
#20362=*
|
||||
exprs(#20362,94,#20357,1,"@C")
|
||||
#20363=@"loc,{#10000},14,15,14,16"
|
||||
@@ -1145,7 +1146,7 @@ exprs(#20364,79,#20362,0,"C")
|
||||
hasLocation(#20364,#20209)
|
||||
expr_containers(#20364,#20346)
|
||||
literals("C","C",#20364)
|
||||
bind(#20364,#20222)
|
||||
bind(#20364,#20224)
|
||||
#20365=*
|
||||
stmts(#20365,1,#20346,-2,"{}")
|
||||
#20366=@"loc,{#10000},14,22,14,23"
|
||||
@@ -1349,8 +1350,8 @@ successor(#20265,#20263)
|
||||
successor(#20263,#20281)
|
||||
successor(#20241,#20266)
|
||||
successor(#20236,#20243)
|
||||
successor(#20230,#20236)
|
||||
successor(#20224,#20230)
|
||||
successor(#20374,#20224)
|
||||
successor(#20231,#20236)
|
||||
successor(#20226,#20231)
|
||||
successor(#20374,#20226)
|
||||
numlines(#10000,15,12,0)
|
||||
filetype(#10000,"typescript")
|
||||
|
||||
@@ -694,506 +694,509 @@ toplevels(#20001,0)
|
||||
#20252=@"loc,{#10000},2,1,30,0"
|
||||
locations_default(#20252,#10000,2,1,30,0)
|
||||
hasLocation(#20001,#20252)
|
||||
#20253=@"var;{C};{#20000}"
|
||||
variables(#20253,"C",#20000)
|
||||
#20254=@"local_type_name;{C};{#20000}"
|
||||
local_type_names(#20254,"C",#20000)
|
||||
#20255=*
|
||||
stmts(#20255,17,#20001,0,"declare ... on f();")
|
||||
hasLocation(#20255,#20020)
|
||||
stmt_containers(#20255,#20001)
|
||||
has_declare_keyword(#20255)
|
||||
#20256=*
|
||||
exprs(#20256,78,#20255,-1,"f")
|
||||
hasLocation(#20256,#20079)
|
||||
expr_containers(#20256,#20255)
|
||||
literals("f","f",#20256)
|
||||
#20257=@"var;{f};{#20000}"
|
||||
variables(#20257,"f",#20000)
|
||||
decl(#20256,#20257)
|
||||
#20253=@"var;{f};{#20000}"
|
||||
variables(#20253,"f",#20000)
|
||||
#20254=@"var;{C};{#20000}"
|
||||
variables(#20254,"C",#20000)
|
||||
#20255=@"var;{D};{#20000}"
|
||||
variables(#20255,"D",#20000)
|
||||
#20256=@"local_type_name;{C};{#20000}"
|
||||
local_type_names(#20256,"C",#20000)
|
||||
#20257=@"local_type_name;{D};{#20000}"
|
||||
local_type_names(#20257,"D",#20000)
|
||||
#20258=*
|
||||
scopes(#20258,1)
|
||||
scopenodes(#20255,#20258)
|
||||
scopenesting(#20258,#20000)
|
||||
#20259=@"var;{arguments};{#20258}"
|
||||
variables(#20259,"arguments",#20258)
|
||||
is_arguments_object(#20259)
|
||||
stmts(#20258,17,#20001,0,"declare ... on f();")
|
||||
hasLocation(#20258,#20020)
|
||||
stmt_containers(#20258,#20001)
|
||||
has_declare_keyword(#20258)
|
||||
#20259=*
|
||||
exprs(#20259,78,#20258,-1,"f")
|
||||
hasLocation(#20259,#20079)
|
||||
expr_containers(#20259,#20258)
|
||||
literals("f","f",#20259)
|
||||
decl(#20259,#20253)
|
||||
#20260=*
|
||||
stmts(#20260,26,#20001,1,"abstrac ... mber;\n}")
|
||||
#20261=@"loc,{#10000},4,1,15,1"
|
||||
locations_default(#20261,#10000,4,1,15,1)
|
||||
hasLocation(#20260,#20261)
|
||||
stmt_containers(#20260,#20001)
|
||||
is_abstract_class(#20260)
|
||||
scopes(#20260,1)
|
||||
scopenodes(#20258,#20260)
|
||||
scopenesting(#20260,#20000)
|
||||
#20261=@"var;{arguments};{#20260}"
|
||||
variables(#20261,"arguments",#20260)
|
||||
is_arguments_object(#20261)
|
||||
#20262=*
|
||||
exprs(#20262,78,#20260,0,"C")
|
||||
hasLocation(#20262,#20091)
|
||||
enclosing_stmt(#20262,#20260)
|
||||
expr_containers(#20262,#20001)
|
||||
literals("C","C",#20262)
|
||||
decl(#20262,#20253)
|
||||
typedecl(#20262,#20254)
|
||||
#20263=*
|
||||
scopes(#20263,10)
|
||||
scopenodes(#20260,#20263)
|
||||
scopenesting(#20263,#20000)
|
||||
stmts(#20262,26,#20001,1,"abstrac ... mber;\n}")
|
||||
#20263=@"loc,{#10000},4,1,15,1"
|
||||
locations_default(#20263,#10000,4,1,15,1)
|
||||
hasLocation(#20262,#20263)
|
||||
stmt_containers(#20262,#20001)
|
||||
is_abstract_class(#20262)
|
||||
#20264=*
|
||||
properties(#20264,#20260,2,0,"abstract h();")
|
||||
#20265=@"loc,{#10000},6,3,6,15"
|
||||
locations_default(#20265,#10000,6,3,6,15)
|
||||
hasLocation(#20264,#20265)
|
||||
exprs(#20264,78,#20262,0,"C")
|
||||
hasLocation(#20264,#20091)
|
||||
enclosing_stmt(#20264,#20262)
|
||||
expr_containers(#20264,#20001)
|
||||
literals("C","C",#20264)
|
||||
decl(#20264,#20254)
|
||||
typedecl(#20264,#20256)
|
||||
#20265=*
|
||||
scopes(#20265,10)
|
||||
scopenodes(#20262,#20265)
|
||||
scopenesting(#20265,#20000)
|
||||
#20266=*
|
||||
exprs(#20266,0,#20264,0,"h")
|
||||
hasLocation(#20266,#20097)
|
||||
enclosing_stmt(#20266,#20260)
|
||||
expr_containers(#20266,#20001)
|
||||
literals("h","h",#20266)
|
||||
#20267=*
|
||||
exprs(#20267,9,#20264,1,"abstract h();")
|
||||
hasLocation(#20267,#20265)
|
||||
enclosing_stmt(#20267,#20260)
|
||||
expr_containers(#20267,#20001)
|
||||
properties(#20266,#20262,2,0,"abstract h();")
|
||||
#20267=@"loc,{#10000},6,3,6,15"
|
||||
locations_default(#20267,#10000,6,3,6,15)
|
||||
hasLocation(#20266,#20267)
|
||||
#20268=*
|
||||
scopes(#20268,1)
|
||||
scopenodes(#20267,#20268)
|
||||
scopenesting(#20268,#20263)
|
||||
#20269=@"var;{arguments};{#20268}"
|
||||
variables(#20269,"arguments",#20268)
|
||||
is_arguments_object(#20269)
|
||||
is_method(#20264)
|
||||
is_abstract_member(#20264)
|
||||
exprs(#20268,0,#20266,0,"h")
|
||||
hasLocation(#20268,#20097)
|
||||
enclosing_stmt(#20268,#20262)
|
||||
expr_containers(#20268,#20001)
|
||||
literals("h","h",#20268)
|
||||
#20269=*
|
||||
exprs(#20269,9,#20266,1,"abstract h();")
|
||||
hasLocation(#20269,#20267)
|
||||
enclosing_stmt(#20269,#20262)
|
||||
expr_containers(#20269,#20001)
|
||||
#20270=*
|
||||
properties(#20270,#20260,3,0,"g(x: nu ... number;")
|
||||
#20271=@"loc,{#10000},9,3,9,23"
|
||||
locations_default(#20271,#10000,9,3,9,23)
|
||||
hasLocation(#20270,#20271)
|
||||
scopes(#20270,1)
|
||||
scopenodes(#20269,#20270)
|
||||
scopenesting(#20270,#20265)
|
||||
#20271=@"var;{arguments};{#20270}"
|
||||
variables(#20271,"arguments",#20270)
|
||||
is_arguments_object(#20271)
|
||||
is_method(#20266)
|
||||
is_abstract_member(#20266)
|
||||
#20272=*
|
||||
exprs(#20272,0,#20270,0,"g")
|
||||
hasLocation(#20272,#20105)
|
||||
enclosing_stmt(#20272,#20260)
|
||||
expr_containers(#20272,#20001)
|
||||
literals("g","g",#20272)
|
||||
#20273=*
|
||||
exprs(#20273,9,#20270,1,"g(x: nu ... number;")
|
||||
hasLocation(#20273,#20271)
|
||||
enclosing_stmt(#20273,#20260)
|
||||
expr_containers(#20273,#20001)
|
||||
properties(#20272,#20262,3,0,"g(x: nu ... number;")
|
||||
#20273=@"loc,{#10000},9,3,9,23"
|
||||
locations_default(#20273,#10000,9,3,9,23)
|
||||
hasLocation(#20272,#20273)
|
||||
#20274=*
|
||||
scopes(#20274,1)
|
||||
scopenodes(#20273,#20274)
|
||||
scopenesting(#20274,#20263)
|
||||
#20275=@"var;{x};{#20274}"
|
||||
variables(#20275,"x",#20274)
|
||||
exprs(#20274,0,#20272,0,"g")
|
||||
hasLocation(#20274,#20105)
|
||||
enclosing_stmt(#20274,#20262)
|
||||
expr_containers(#20274,#20001)
|
||||
literals("g","g",#20274)
|
||||
#20275=*
|
||||
exprs(#20275,9,#20272,1,"g(x: nu ... number;")
|
||||
hasLocation(#20275,#20273)
|
||||
enclosing_stmt(#20275,#20262)
|
||||
expr_containers(#20275,#20001)
|
||||
#20276=*
|
||||
exprs(#20276,78,#20273,0,"x")
|
||||
hasLocation(#20276,#20109)
|
||||
expr_containers(#20276,#20273)
|
||||
literals("x","x",#20276)
|
||||
decl(#20276,#20275)
|
||||
#20277=@"var;{arguments};{#20274}"
|
||||
variables(#20277,"arguments",#20274)
|
||||
is_arguments_object(#20277)
|
||||
scopes(#20276,1)
|
||||
scopenodes(#20275,#20276)
|
||||
scopenesting(#20276,#20265)
|
||||
#20277=@"var;{x};{#20276}"
|
||||
variables(#20277,"x",#20276)
|
||||
#20278=*
|
||||
typeexprs(#20278,2,#20273,-3,"number")
|
||||
hasLocation(#20278,#20119)
|
||||
expr_containers(#20278,#20273)
|
||||
literals("number","number",#20278)
|
||||
#20279=*
|
||||
typeexprs(#20279,2,#20273,-6,"number")
|
||||
hasLocation(#20279,#20113)
|
||||
expr_containers(#20279,#20273)
|
||||
literals("number","number",#20279)
|
||||
is_method(#20270)
|
||||
exprs(#20278,78,#20275,0,"x")
|
||||
hasLocation(#20278,#20109)
|
||||
expr_containers(#20278,#20275)
|
||||
literals("x","x",#20278)
|
||||
decl(#20278,#20277)
|
||||
#20279=@"var;{arguments};{#20276}"
|
||||
variables(#20279,"arguments",#20276)
|
||||
is_arguments_object(#20279)
|
||||
#20280=*
|
||||
properties(#20280,#20260,4,0,"g(x: st ... string;")
|
||||
#20281=@"loc,{#10000},10,3,10,23"
|
||||
locations_default(#20281,#10000,10,3,10,23)
|
||||
hasLocation(#20280,#20281)
|
||||
typeexprs(#20280,2,#20275,-3,"number")
|
||||
hasLocation(#20280,#20119)
|
||||
expr_containers(#20280,#20275)
|
||||
literals("number","number",#20280)
|
||||
#20281=*
|
||||
typeexprs(#20281,2,#20275,-6,"number")
|
||||
hasLocation(#20281,#20113)
|
||||
expr_containers(#20281,#20275)
|
||||
literals("number","number",#20281)
|
||||
is_method(#20272)
|
||||
#20282=*
|
||||
exprs(#20282,0,#20280,0,"g")
|
||||
hasLocation(#20282,#20123)
|
||||
enclosing_stmt(#20282,#20260)
|
||||
expr_containers(#20282,#20001)
|
||||
literals("g","g",#20282)
|
||||
#20283=*
|
||||
exprs(#20283,9,#20280,1,"g(x: st ... string;")
|
||||
hasLocation(#20283,#20281)
|
||||
enclosing_stmt(#20283,#20260)
|
||||
expr_containers(#20283,#20001)
|
||||
properties(#20282,#20262,4,0,"g(x: st ... string;")
|
||||
#20283=@"loc,{#10000},10,3,10,23"
|
||||
locations_default(#20283,#10000,10,3,10,23)
|
||||
hasLocation(#20282,#20283)
|
||||
#20284=*
|
||||
scopes(#20284,1)
|
||||
scopenodes(#20283,#20284)
|
||||
scopenesting(#20284,#20263)
|
||||
#20285=@"var;{x};{#20284}"
|
||||
variables(#20285,"x",#20284)
|
||||
exprs(#20284,0,#20282,0,"g")
|
||||
hasLocation(#20284,#20123)
|
||||
enclosing_stmt(#20284,#20262)
|
||||
expr_containers(#20284,#20001)
|
||||
literals("g","g",#20284)
|
||||
#20285=*
|
||||
exprs(#20285,9,#20282,1,"g(x: st ... string;")
|
||||
hasLocation(#20285,#20283)
|
||||
enclosing_stmt(#20285,#20262)
|
||||
expr_containers(#20285,#20001)
|
||||
#20286=*
|
||||
exprs(#20286,78,#20283,0,"x")
|
||||
hasLocation(#20286,#20127)
|
||||
expr_containers(#20286,#20283)
|
||||
literals("x","x",#20286)
|
||||
decl(#20286,#20285)
|
||||
#20287=@"var;{arguments};{#20284}"
|
||||
variables(#20287,"arguments",#20284)
|
||||
is_arguments_object(#20287)
|
||||
scopes(#20286,1)
|
||||
scopenodes(#20285,#20286)
|
||||
scopenesting(#20286,#20265)
|
||||
#20287=@"var;{x};{#20286}"
|
||||
variables(#20287,"x",#20286)
|
||||
#20288=*
|
||||
typeexprs(#20288,2,#20283,-3,"string")
|
||||
hasLocation(#20288,#20137)
|
||||
expr_containers(#20288,#20283)
|
||||
literals("string","string",#20288)
|
||||
#20289=*
|
||||
typeexprs(#20289,2,#20283,-6,"string")
|
||||
hasLocation(#20289,#20131)
|
||||
expr_containers(#20289,#20283)
|
||||
literals("string","string",#20289)
|
||||
is_method(#20280)
|
||||
exprs(#20288,78,#20285,0,"x")
|
||||
hasLocation(#20288,#20127)
|
||||
expr_containers(#20288,#20285)
|
||||
literals("x","x",#20288)
|
||||
decl(#20288,#20287)
|
||||
#20289=@"var;{arguments};{#20286}"
|
||||
variables(#20289,"arguments",#20286)
|
||||
is_arguments_object(#20289)
|
||||
#20290=*
|
||||
properties(#20290,#20260,5,0,"g(x: any) {}")
|
||||
#20291=@"loc,{#10000},11,3,11,14"
|
||||
locations_default(#20291,#10000,11,3,11,14)
|
||||
hasLocation(#20290,#20291)
|
||||
typeexprs(#20290,2,#20285,-3,"string")
|
||||
hasLocation(#20290,#20137)
|
||||
expr_containers(#20290,#20285)
|
||||
literals("string","string",#20290)
|
||||
#20291=*
|
||||
typeexprs(#20291,2,#20285,-6,"string")
|
||||
hasLocation(#20291,#20131)
|
||||
expr_containers(#20291,#20285)
|
||||
literals("string","string",#20291)
|
||||
is_method(#20282)
|
||||
#20292=*
|
||||
exprs(#20292,0,#20290,0,"g")
|
||||
hasLocation(#20292,#20141)
|
||||
enclosing_stmt(#20292,#20260)
|
||||
expr_containers(#20292,#20001)
|
||||
literals("g","g",#20292)
|
||||
#20293=*
|
||||
exprs(#20293,9,#20290,1,"g(x: any) {}")
|
||||
hasLocation(#20293,#20291)
|
||||
enclosing_stmt(#20293,#20260)
|
||||
expr_containers(#20293,#20001)
|
||||
properties(#20292,#20262,5,0,"g(x: any) {}")
|
||||
#20293=@"loc,{#10000},11,3,11,14"
|
||||
locations_default(#20293,#10000,11,3,11,14)
|
||||
hasLocation(#20292,#20293)
|
||||
#20294=*
|
||||
scopes(#20294,1)
|
||||
scopenodes(#20293,#20294)
|
||||
scopenesting(#20294,#20263)
|
||||
#20295=@"var;{x};{#20294}"
|
||||
variables(#20295,"x",#20294)
|
||||
exprs(#20294,0,#20292,0,"g")
|
||||
hasLocation(#20294,#20141)
|
||||
enclosing_stmt(#20294,#20262)
|
||||
expr_containers(#20294,#20001)
|
||||
literals("g","g",#20294)
|
||||
#20295=*
|
||||
exprs(#20295,9,#20292,1,"g(x: any) {}")
|
||||
hasLocation(#20295,#20293)
|
||||
enclosing_stmt(#20295,#20262)
|
||||
expr_containers(#20295,#20001)
|
||||
#20296=*
|
||||
exprs(#20296,78,#20293,0,"x")
|
||||
hasLocation(#20296,#20145)
|
||||
expr_containers(#20296,#20293)
|
||||
literals("x","x",#20296)
|
||||
decl(#20296,#20295)
|
||||
#20297=@"var;{arguments};{#20294}"
|
||||
variables(#20297,"arguments",#20294)
|
||||
is_arguments_object(#20297)
|
||||
scopes(#20296,1)
|
||||
scopenodes(#20295,#20296)
|
||||
scopenesting(#20296,#20265)
|
||||
#20297=@"var;{x};{#20296}"
|
||||
variables(#20297,"x",#20296)
|
||||
#20298=*
|
||||
typeexprs(#20298,2,#20293,-6,"any")
|
||||
hasLocation(#20298,#20149)
|
||||
expr_containers(#20298,#20293)
|
||||
literals("any","any",#20298)
|
||||
#20299=*
|
||||
stmts(#20299,1,#20293,-2,"{}")
|
||||
#20300=@"loc,{#10000},11,13,11,14"
|
||||
locations_default(#20300,#10000,11,13,11,14)
|
||||
hasLocation(#20299,#20300)
|
||||
stmt_containers(#20299,#20293)
|
||||
is_method(#20290)
|
||||
exprs(#20298,78,#20295,0,"x")
|
||||
hasLocation(#20298,#20145)
|
||||
expr_containers(#20298,#20295)
|
||||
literals("x","x",#20298)
|
||||
decl(#20298,#20297)
|
||||
#20299=@"var;{arguments};{#20296}"
|
||||
variables(#20299,"arguments",#20296)
|
||||
is_arguments_object(#20299)
|
||||
#20300=*
|
||||
typeexprs(#20300,2,#20295,-6,"any")
|
||||
hasLocation(#20300,#20149)
|
||||
expr_containers(#20300,#20295)
|
||||
literals("any","any",#20300)
|
||||
#20301=*
|
||||
properties(#20301,#20260,6,8,"abstract x: number;")
|
||||
#20302=@"loc,{#10000},14,3,14,21"
|
||||
locations_default(#20302,#10000,14,3,14,21)
|
||||
stmts(#20301,1,#20295,-2,"{}")
|
||||
#20302=@"loc,{#10000},11,13,11,14"
|
||||
locations_default(#20302,#10000,11,13,11,14)
|
||||
hasLocation(#20301,#20302)
|
||||
stmt_containers(#20301,#20295)
|
||||
is_method(#20292)
|
||||
#20303=*
|
||||
#20304=*
|
||||
exprs(#20304,0,#20301,0,"x")
|
||||
hasLocation(#20304,#20159)
|
||||
expr_containers(#20304,#20303)
|
||||
literals("x","x",#20304)
|
||||
is_abstract_member(#20301)
|
||||
properties(#20303,#20262,6,8,"abstract x: number;")
|
||||
#20304=@"loc,{#10000},14,3,14,21"
|
||||
locations_default(#20304,#10000,14,3,14,21)
|
||||
hasLocation(#20303,#20304)
|
||||
#20305=*
|
||||
typeexprs(#20305,2,#20301,2,"number")
|
||||
hasLocation(#20305,#20163)
|
||||
enclosing_stmt(#20305,#20260)
|
||||
expr_containers(#20305,#20001)
|
||||
literals("number","number",#20305)
|
||||
#20306=*
|
||||
properties(#20306,#20260,7,0,"constructor() {}")
|
||||
#20307=@"loc,{#10000},4,18,4,17"
|
||||
locations_default(#20307,#10000,4,18,4,17)
|
||||
hasLocation(#20306,#20307)
|
||||
exprs(#20306,0,#20303,0,"x")
|
||||
hasLocation(#20306,#20159)
|
||||
expr_containers(#20306,#20305)
|
||||
literals("x","x",#20306)
|
||||
is_abstract_member(#20303)
|
||||
#20307=*
|
||||
typeexprs(#20307,2,#20303,2,"number")
|
||||
hasLocation(#20307,#20163)
|
||||
enclosing_stmt(#20307,#20262)
|
||||
expr_containers(#20307,#20001)
|
||||
literals("number","number",#20307)
|
||||
#20308=*
|
||||
exprs(#20308,0,#20306,0,"constructor")
|
||||
hasLocation(#20308,#20307)
|
||||
enclosing_stmt(#20308,#20260)
|
||||
expr_containers(#20308,#20001)
|
||||
literals("constructor","constructor",#20308)
|
||||
exprs(#20303,9,#20306,1,"() {}")
|
||||
hasLocation(#20303,#20307)
|
||||
enclosing_stmt(#20303,#20260)
|
||||
expr_containers(#20303,#20001)
|
||||
#20309=*
|
||||
scopes(#20309,1)
|
||||
scopenodes(#20303,#20309)
|
||||
scopenesting(#20309,#20263)
|
||||
#20310=@"var;{arguments};{#20309}"
|
||||
variables(#20310,"arguments",#20309)
|
||||
is_arguments_object(#20310)
|
||||
properties(#20308,#20262,7,0,"constructor() {}")
|
||||
#20309=@"loc,{#10000},4,18,4,17"
|
||||
locations_default(#20309,#10000,4,18,4,17)
|
||||
hasLocation(#20308,#20309)
|
||||
#20310=*
|
||||
exprs(#20310,0,#20308,0,"constructor")
|
||||
hasLocation(#20310,#20309)
|
||||
enclosing_stmt(#20310,#20262)
|
||||
expr_containers(#20310,#20001)
|
||||
literals("constructor","constructor",#20310)
|
||||
exprs(#20305,9,#20308,1,"() {}")
|
||||
hasLocation(#20305,#20309)
|
||||
enclosing_stmt(#20305,#20262)
|
||||
expr_containers(#20305,#20001)
|
||||
#20311=*
|
||||
stmts(#20311,1,#20303,-2,"{}")
|
||||
hasLocation(#20311,#20307)
|
||||
stmt_containers(#20311,#20303)
|
||||
is_method(#20306)
|
||||
#20312=*
|
||||
stmts(#20312,26,#20001,2,"declare ... mber;\n}")
|
||||
#20313=@"loc,{#10000},18,1,29,1"
|
||||
locations_default(#20313,#10000,18,1,29,1)
|
||||
hasLocation(#20312,#20313)
|
||||
stmt_containers(#20312,#20001)
|
||||
has_declare_keyword(#20312)
|
||||
is_abstract_class(#20312)
|
||||
scopes(#20311,1)
|
||||
scopenodes(#20305,#20311)
|
||||
scopenesting(#20311,#20265)
|
||||
#20312=@"var;{arguments};{#20311}"
|
||||
variables(#20312,"arguments",#20311)
|
||||
is_arguments_object(#20312)
|
||||
#20313=*
|
||||
stmts(#20313,1,#20305,-2,"{}")
|
||||
hasLocation(#20313,#20309)
|
||||
stmt_containers(#20313,#20305)
|
||||
is_method(#20308)
|
||||
#20314=*
|
||||
exprs(#20314,78,#20312,0,"D")
|
||||
hasLocation(#20314,#20174)
|
||||
enclosing_stmt(#20314,#20312)
|
||||
expr_containers(#20314,#20001)
|
||||
literals("D","D",#20314)
|
||||
#20315=@"var;{D};{#20000}"
|
||||
variables(#20315,"D",#20000)
|
||||
decl(#20314,#20315)
|
||||
stmts(#20314,26,#20001,2,"declare ... mber;\n}")
|
||||
#20315=@"loc,{#10000},18,1,29,1"
|
||||
locations_default(#20315,#10000,18,1,29,1)
|
||||
hasLocation(#20314,#20315)
|
||||
stmt_containers(#20314,#20001)
|
||||
has_declare_keyword(#20314)
|
||||
is_abstract_class(#20314)
|
||||
#20316=*
|
||||
scopes(#20316,10)
|
||||
scopenodes(#20312,#20316)
|
||||
scopenesting(#20316,#20000)
|
||||
exprs(#20316,78,#20314,0,"D")
|
||||
hasLocation(#20316,#20174)
|
||||
enclosing_stmt(#20316,#20314)
|
||||
expr_containers(#20316,#20001)
|
||||
literals("D","D",#20316)
|
||||
decl(#20316,#20255)
|
||||
typedecl(#20316,#20257)
|
||||
#20317=*
|
||||
properties(#20317,#20312,2,0,"abstract h();")
|
||||
#20318=@"loc,{#10000},20,3,20,15"
|
||||
locations_default(#20318,#10000,20,3,20,15)
|
||||
hasLocation(#20317,#20318)
|
||||
#20319=*
|
||||
exprs(#20319,0,#20317,0,"h")
|
||||
hasLocation(#20319,#20180)
|
||||
enclosing_stmt(#20319,#20312)
|
||||
expr_containers(#20319,#20001)
|
||||
literals("h","h",#20319)
|
||||
scopes(#20317,10)
|
||||
scopenodes(#20314,#20317)
|
||||
scopenesting(#20317,#20000)
|
||||
#20318=*
|
||||
properties(#20318,#20314,2,0,"abstract h();")
|
||||
#20319=@"loc,{#10000},20,3,20,15"
|
||||
locations_default(#20319,#10000,20,3,20,15)
|
||||
hasLocation(#20318,#20319)
|
||||
#20320=*
|
||||
exprs(#20320,9,#20317,1,"abstract h();")
|
||||
hasLocation(#20320,#20318)
|
||||
enclosing_stmt(#20320,#20312)
|
||||
exprs(#20320,0,#20318,0,"h")
|
||||
hasLocation(#20320,#20180)
|
||||
enclosing_stmt(#20320,#20314)
|
||||
expr_containers(#20320,#20001)
|
||||
literals("h","h",#20320)
|
||||
#20321=*
|
||||
scopes(#20321,1)
|
||||
scopenodes(#20320,#20321)
|
||||
scopenesting(#20321,#20316)
|
||||
#20322=@"var;{arguments};{#20321}"
|
||||
variables(#20322,"arguments",#20321)
|
||||
is_arguments_object(#20322)
|
||||
is_method(#20317)
|
||||
is_abstract_member(#20317)
|
||||
#20323=*
|
||||
properties(#20323,#20312,3,0,"g(x: nu ... number;")
|
||||
#20324=@"loc,{#10000},23,3,23,23"
|
||||
locations_default(#20324,#10000,23,3,23,23)
|
||||
hasLocation(#20323,#20324)
|
||||
#20325=*
|
||||
exprs(#20325,0,#20323,0,"g")
|
||||
hasLocation(#20325,#20188)
|
||||
enclosing_stmt(#20325,#20312)
|
||||
expr_containers(#20325,#20001)
|
||||
literals("g","g",#20325)
|
||||
exprs(#20321,9,#20318,1,"abstract h();")
|
||||
hasLocation(#20321,#20319)
|
||||
enclosing_stmt(#20321,#20314)
|
||||
expr_containers(#20321,#20001)
|
||||
#20322=*
|
||||
scopes(#20322,1)
|
||||
scopenodes(#20321,#20322)
|
||||
scopenesting(#20322,#20317)
|
||||
#20323=@"var;{arguments};{#20322}"
|
||||
variables(#20323,"arguments",#20322)
|
||||
is_arguments_object(#20323)
|
||||
is_method(#20318)
|
||||
is_abstract_member(#20318)
|
||||
#20324=*
|
||||
properties(#20324,#20314,3,0,"g(x: nu ... number;")
|
||||
#20325=@"loc,{#10000},23,3,23,23"
|
||||
locations_default(#20325,#10000,23,3,23,23)
|
||||
hasLocation(#20324,#20325)
|
||||
#20326=*
|
||||
exprs(#20326,9,#20323,1,"g(x: nu ... number;")
|
||||
hasLocation(#20326,#20324)
|
||||
enclosing_stmt(#20326,#20312)
|
||||
exprs(#20326,0,#20324,0,"g")
|
||||
hasLocation(#20326,#20188)
|
||||
enclosing_stmt(#20326,#20314)
|
||||
expr_containers(#20326,#20001)
|
||||
literals("g","g",#20326)
|
||||
#20327=*
|
||||
scopes(#20327,1)
|
||||
scopenodes(#20326,#20327)
|
||||
scopenesting(#20327,#20316)
|
||||
#20328=@"var;{x};{#20327}"
|
||||
variables(#20328,"x",#20327)
|
||||
#20329=*
|
||||
exprs(#20329,78,#20326,0,"x")
|
||||
hasLocation(#20329,#20192)
|
||||
expr_containers(#20329,#20326)
|
||||
literals("x","x",#20329)
|
||||
decl(#20329,#20328)
|
||||
#20330=@"var;{arguments};{#20327}"
|
||||
variables(#20330,"arguments",#20327)
|
||||
is_arguments_object(#20330)
|
||||
#20331=*
|
||||
typeexprs(#20331,2,#20326,-3,"number")
|
||||
hasLocation(#20331,#20202)
|
||||
expr_containers(#20331,#20326)
|
||||
literals("number","number",#20331)
|
||||
exprs(#20327,9,#20324,1,"g(x: nu ... number;")
|
||||
hasLocation(#20327,#20325)
|
||||
enclosing_stmt(#20327,#20314)
|
||||
expr_containers(#20327,#20001)
|
||||
#20328=*
|
||||
scopes(#20328,1)
|
||||
scopenodes(#20327,#20328)
|
||||
scopenesting(#20328,#20317)
|
||||
#20329=@"var;{x};{#20328}"
|
||||
variables(#20329,"x",#20328)
|
||||
#20330=*
|
||||
exprs(#20330,78,#20327,0,"x")
|
||||
hasLocation(#20330,#20192)
|
||||
expr_containers(#20330,#20327)
|
||||
literals("x","x",#20330)
|
||||
decl(#20330,#20329)
|
||||
#20331=@"var;{arguments};{#20328}"
|
||||
variables(#20331,"arguments",#20328)
|
||||
is_arguments_object(#20331)
|
||||
#20332=*
|
||||
typeexprs(#20332,2,#20326,-6,"number")
|
||||
hasLocation(#20332,#20196)
|
||||
expr_containers(#20332,#20326)
|
||||
typeexprs(#20332,2,#20327,-3,"number")
|
||||
hasLocation(#20332,#20202)
|
||||
expr_containers(#20332,#20327)
|
||||
literals("number","number",#20332)
|
||||
is_method(#20323)
|
||||
#20333=*
|
||||
properties(#20333,#20312,4,0,"g(x: st ... string;")
|
||||
#20334=@"loc,{#10000},24,3,24,23"
|
||||
locations_default(#20334,#10000,24,3,24,23)
|
||||
hasLocation(#20333,#20334)
|
||||
#20335=*
|
||||
exprs(#20335,0,#20333,0,"g")
|
||||
hasLocation(#20335,#20206)
|
||||
enclosing_stmt(#20335,#20312)
|
||||
expr_containers(#20335,#20001)
|
||||
literals("g","g",#20335)
|
||||
typeexprs(#20333,2,#20327,-6,"number")
|
||||
hasLocation(#20333,#20196)
|
||||
expr_containers(#20333,#20327)
|
||||
literals("number","number",#20333)
|
||||
is_method(#20324)
|
||||
#20334=*
|
||||
properties(#20334,#20314,4,0,"g(x: st ... string;")
|
||||
#20335=@"loc,{#10000},24,3,24,23"
|
||||
locations_default(#20335,#10000,24,3,24,23)
|
||||
hasLocation(#20334,#20335)
|
||||
#20336=*
|
||||
exprs(#20336,9,#20333,1,"g(x: st ... string;")
|
||||
hasLocation(#20336,#20334)
|
||||
enclosing_stmt(#20336,#20312)
|
||||
exprs(#20336,0,#20334,0,"g")
|
||||
hasLocation(#20336,#20206)
|
||||
enclosing_stmt(#20336,#20314)
|
||||
expr_containers(#20336,#20001)
|
||||
literals("g","g",#20336)
|
||||
#20337=*
|
||||
scopes(#20337,1)
|
||||
scopenodes(#20336,#20337)
|
||||
scopenesting(#20337,#20316)
|
||||
#20338=@"var;{x};{#20337}"
|
||||
variables(#20338,"x",#20337)
|
||||
#20339=*
|
||||
exprs(#20339,78,#20336,0,"x")
|
||||
hasLocation(#20339,#20210)
|
||||
expr_containers(#20339,#20336)
|
||||
literals("x","x",#20339)
|
||||
decl(#20339,#20338)
|
||||
#20340=@"var;{arguments};{#20337}"
|
||||
variables(#20340,"arguments",#20337)
|
||||
is_arguments_object(#20340)
|
||||
#20341=*
|
||||
typeexprs(#20341,2,#20336,-3,"string")
|
||||
hasLocation(#20341,#20220)
|
||||
expr_containers(#20341,#20336)
|
||||
literals("string","string",#20341)
|
||||
exprs(#20337,9,#20334,1,"g(x: st ... string;")
|
||||
hasLocation(#20337,#20335)
|
||||
enclosing_stmt(#20337,#20314)
|
||||
expr_containers(#20337,#20001)
|
||||
#20338=*
|
||||
scopes(#20338,1)
|
||||
scopenodes(#20337,#20338)
|
||||
scopenesting(#20338,#20317)
|
||||
#20339=@"var;{x};{#20338}"
|
||||
variables(#20339,"x",#20338)
|
||||
#20340=*
|
||||
exprs(#20340,78,#20337,0,"x")
|
||||
hasLocation(#20340,#20210)
|
||||
expr_containers(#20340,#20337)
|
||||
literals("x","x",#20340)
|
||||
decl(#20340,#20339)
|
||||
#20341=@"var;{arguments};{#20338}"
|
||||
variables(#20341,"arguments",#20338)
|
||||
is_arguments_object(#20341)
|
||||
#20342=*
|
||||
typeexprs(#20342,2,#20336,-6,"string")
|
||||
hasLocation(#20342,#20214)
|
||||
expr_containers(#20342,#20336)
|
||||
typeexprs(#20342,2,#20337,-3,"string")
|
||||
hasLocation(#20342,#20220)
|
||||
expr_containers(#20342,#20337)
|
||||
literals("string","string",#20342)
|
||||
is_method(#20333)
|
||||
#20343=*
|
||||
properties(#20343,#20312,5,0,"g(x: any) {}")
|
||||
#20344=@"loc,{#10000},25,3,25,14"
|
||||
locations_default(#20344,#10000,25,3,25,14)
|
||||
hasLocation(#20343,#20344)
|
||||
#20345=*
|
||||
exprs(#20345,0,#20343,0,"g")
|
||||
hasLocation(#20345,#20224)
|
||||
enclosing_stmt(#20345,#20312)
|
||||
expr_containers(#20345,#20001)
|
||||
literals("g","g",#20345)
|
||||
typeexprs(#20343,2,#20337,-6,"string")
|
||||
hasLocation(#20343,#20214)
|
||||
expr_containers(#20343,#20337)
|
||||
literals("string","string",#20343)
|
||||
is_method(#20334)
|
||||
#20344=*
|
||||
properties(#20344,#20314,5,0,"g(x: any) {}")
|
||||
#20345=@"loc,{#10000},25,3,25,14"
|
||||
locations_default(#20345,#10000,25,3,25,14)
|
||||
hasLocation(#20344,#20345)
|
||||
#20346=*
|
||||
exprs(#20346,9,#20343,1,"g(x: any) {}")
|
||||
hasLocation(#20346,#20344)
|
||||
enclosing_stmt(#20346,#20312)
|
||||
exprs(#20346,0,#20344,0,"g")
|
||||
hasLocation(#20346,#20224)
|
||||
enclosing_stmt(#20346,#20314)
|
||||
expr_containers(#20346,#20001)
|
||||
literals("g","g",#20346)
|
||||
#20347=*
|
||||
scopes(#20347,1)
|
||||
scopenodes(#20346,#20347)
|
||||
scopenesting(#20347,#20316)
|
||||
#20348=@"var;{x};{#20347}"
|
||||
variables(#20348,"x",#20347)
|
||||
#20349=*
|
||||
exprs(#20349,78,#20346,0,"x")
|
||||
hasLocation(#20349,#20228)
|
||||
expr_containers(#20349,#20346)
|
||||
literals("x","x",#20349)
|
||||
decl(#20349,#20348)
|
||||
#20350=@"var;{arguments};{#20347}"
|
||||
variables(#20350,"arguments",#20347)
|
||||
is_arguments_object(#20350)
|
||||
#20351=*
|
||||
typeexprs(#20351,2,#20346,-6,"any")
|
||||
hasLocation(#20351,#20232)
|
||||
expr_containers(#20351,#20346)
|
||||
literals("any","any",#20351)
|
||||
exprs(#20347,9,#20344,1,"g(x: any) {}")
|
||||
hasLocation(#20347,#20345)
|
||||
enclosing_stmt(#20347,#20314)
|
||||
expr_containers(#20347,#20001)
|
||||
#20348=*
|
||||
scopes(#20348,1)
|
||||
scopenodes(#20347,#20348)
|
||||
scopenesting(#20348,#20317)
|
||||
#20349=@"var;{x};{#20348}"
|
||||
variables(#20349,"x",#20348)
|
||||
#20350=*
|
||||
exprs(#20350,78,#20347,0,"x")
|
||||
hasLocation(#20350,#20228)
|
||||
expr_containers(#20350,#20347)
|
||||
literals("x","x",#20350)
|
||||
decl(#20350,#20349)
|
||||
#20351=@"var;{arguments};{#20348}"
|
||||
variables(#20351,"arguments",#20348)
|
||||
is_arguments_object(#20351)
|
||||
#20352=*
|
||||
stmts(#20352,1,#20346,-2,"{}")
|
||||
#20353=@"loc,{#10000},25,13,25,14"
|
||||
locations_default(#20353,#10000,25,13,25,14)
|
||||
hasLocation(#20352,#20353)
|
||||
stmt_containers(#20352,#20346)
|
||||
is_method(#20343)
|
||||
#20354=*
|
||||
properties(#20354,#20312,6,8,"abstract x: number;")
|
||||
#20355=@"loc,{#10000},28,3,28,21"
|
||||
locations_default(#20355,#10000,28,3,28,21)
|
||||
hasLocation(#20354,#20355)
|
||||
#20356=*
|
||||
typeexprs(#20352,2,#20347,-6,"any")
|
||||
hasLocation(#20352,#20232)
|
||||
expr_containers(#20352,#20347)
|
||||
literals("any","any",#20352)
|
||||
#20353=*
|
||||
stmts(#20353,1,#20347,-2,"{}")
|
||||
#20354=@"loc,{#10000},25,13,25,14"
|
||||
locations_default(#20354,#10000,25,13,25,14)
|
||||
hasLocation(#20353,#20354)
|
||||
stmt_containers(#20353,#20347)
|
||||
is_method(#20344)
|
||||
#20355=*
|
||||
properties(#20355,#20314,6,8,"abstract x: number;")
|
||||
#20356=@"loc,{#10000},28,3,28,21"
|
||||
locations_default(#20356,#10000,28,3,28,21)
|
||||
hasLocation(#20355,#20356)
|
||||
#20357=*
|
||||
exprs(#20357,0,#20354,0,"x")
|
||||
hasLocation(#20357,#20242)
|
||||
expr_containers(#20357,#20356)
|
||||
literals("x","x",#20357)
|
||||
is_abstract_member(#20354)
|
||||
#20358=*
|
||||
typeexprs(#20358,2,#20354,2,"number")
|
||||
hasLocation(#20358,#20246)
|
||||
enclosing_stmt(#20358,#20312)
|
||||
expr_containers(#20358,#20001)
|
||||
literals("number","number",#20358)
|
||||
exprs(#20358,0,#20355,0,"x")
|
||||
hasLocation(#20358,#20242)
|
||||
expr_containers(#20358,#20357)
|
||||
literals("x","x",#20358)
|
||||
is_abstract_member(#20355)
|
||||
#20359=*
|
||||
properties(#20359,#20312,7,0,"constructor() {}")
|
||||
#20360=@"loc,{#10000},18,26,18,25"
|
||||
locations_default(#20360,#10000,18,26,18,25)
|
||||
hasLocation(#20359,#20360)
|
||||
#20361=*
|
||||
exprs(#20361,0,#20359,0,"constructor")
|
||||
hasLocation(#20361,#20360)
|
||||
enclosing_stmt(#20361,#20312)
|
||||
expr_containers(#20361,#20001)
|
||||
literals("constructor","constructor",#20361)
|
||||
exprs(#20356,9,#20359,1,"() {}")
|
||||
hasLocation(#20356,#20360)
|
||||
enclosing_stmt(#20356,#20312)
|
||||
expr_containers(#20356,#20001)
|
||||
typeexprs(#20359,2,#20355,2,"number")
|
||||
hasLocation(#20359,#20246)
|
||||
enclosing_stmt(#20359,#20314)
|
||||
expr_containers(#20359,#20001)
|
||||
literals("number","number",#20359)
|
||||
#20360=*
|
||||
properties(#20360,#20314,7,0,"constructor() {}")
|
||||
#20361=@"loc,{#10000},18,26,18,25"
|
||||
locations_default(#20361,#10000,18,26,18,25)
|
||||
hasLocation(#20360,#20361)
|
||||
#20362=*
|
||||
scopes(#20362,1)
|
||||
scopenodes(#20356,#20362)
|
||||
scopenesting(#20362,#20316)
|
||||
#20363=@"var;{arguments};{#20362}"
|
||||
variables(#20363,"arguments",#20362)
|
||||
is_arguments_object(#20363)
|
||||
#20364=*
|
||||
stmts(#20364,1,#20356,-2,"{}")
|
||||
hasLocation(#20364,#20360)
|
||||
stmt_containers(#20364,#20356)
|
||||
is_method(#20359)
|
||||
exprs(#20362,0,#20360,0,"constructor")
|
||||
hasLocation(#20362,#20361)
|
||||
enclosing_stmt(#20362,#20314)
|
||||
expr_containers(#20362,#20001)
|
||||
literals("constructor","constructor",#20362)
|
||||
exprs(#20357,9,#20360,1,"() {}")
|
||||
hasLocation(#20357,#20361)
|
||||
enclosing_stmt(#20357,#20314)
|
||||
expr_containers(#20357,#20001)
|
||||
#20363=*
|
||||
scopes(#20363,1)
|
||||
scopenodes(#20357,#20363)
|
||||
scopenesting(#20363,#20317)
|
||||
#20364=@"var;{arguments};{#20363}"
|
||||
variables(#20364,"arguments",#20363)
|
||||
is_arguments_object(#20364)
|
||||
#20365=*
|
||||
entry_cfg_node(#20365,#20001)
|
||||
#20366=@"loc,{#10000},2,1,2,0"
|
||||
locations_default(#20366,#10000,2,1,2,0)
|
||||
hasLocation(#20365,#20366)
|
||||
#20367=*
|
||||
exit_cfg_node(#20367,#20001)
|
||||
hasLocation(#20367,#20251)
|
||||
successor(#20312,#20367)
|
||||
successor(#20303,#20306)
|
||||
stmts(#20365,1,#20357,-2,"{}")
|
||||
hasLocation(#20365,#20361)
|
||||
stmt_containers(#20365,#20357)
|
||||
is_method(#20360)
|
||||
#20366=*
|
||||
entry_cfg_node(#20366,#20001)
|
||||
#20367=@"loc,{#10000},2,1,2,0"
|
||||
locations_default(#20367,#10000,2,1,2,0)
|
||||
hasLocation(#20366,#20367)
|
||||
#20368=*
|
||||
entry_cfg_node(#20368,#20303)
|
||||
hasLocation(#20368,#20307)
|
||||
exit_cfg_node(#20368,#20001)
|
||||
hasLocation(#20368,#20251)
|
||||
successor(#20314,#20368)
|
||||
successor(#20305,#20308)
|
||||
#20369=*
|
||||
exit_cfg_node(#20369,#20303)
|
||||
hasLocation(#20369,#20307)
|
||||
successor(#20311,#20369)
|
||||
successor(#20368,#20311)
|
||||
successor(#20308,#20303)
|
||||
successor(#20306,#20260)
|
||||
successor(#20293,#20290)
|
||||
entry_cfg_node(#20369,#20305)
|
||||
hasLocation(#20369,#20309)
|
||||
#20370=*
|
||||
entry_cfg_node(#20370,#20293)
|
||||
#20371=@"loc,{#10000},11,3,11,2"
|
||||
locations_default(#20371,#10000,11,3,11,2)
|
||||
hasLocation(#20370,#20371)
|
||||
#20372=*
|
||||
exit_cfg_node(#20372,#20293)
|
||||
#20373=@"loc,{#10000},11,15,11,14"
|
||||
locations_default(#20373,#10000,11,15,11,14)
|
||||
hasLocation(#20372,#20373)
|
||||
successor(#20299,#20372)
|
||||
successor(#20296,#20299)
|
||||
successor(#20370,#20296)
|
||||
successor(#20292,#20293)
|
||||
successor(#20290,#20308)
|
||||
successor(#20280,#20292)
|
||||
successor(#20270,#20280)
|
||||
successor(#20264,#20270)
|
||||
successor(#20262,#20264)
|
||||
successor(#20260,#20312)
|
||||
successor(#20255,#20262)
|
||||
successor(#20365,#20255)
|
||||
exit_cfg_node(#20370,#20305)
|
||||
hasLocation(#20370,#20309)
|
||||
successor(#20313,#20370)
|
||||
successor(#20369,#20313)
|
||||
successor(#20310,#20305)
|
||||
successor(#20308,#20262)
|
||||
successor(#20295,#20292)
|
||||
#20371=*
|
||||
entry_cfg_node(#20371,#20295)
|
||||
#20372=@"loc,{#10000},11,3,11,2"
|
||||
locations_default(#20372,#10000,11,3,11,2)
|
||||
hasLocation(#20371,#20372)
|
||||
#20373=*
|
||||
exit_cfg_node(#20373,#20295)
|
||||
#20374=@"loc,{#10000},11,15,11,14"
|
||||
locations_default(#20374,#10000,11,15,11,14)
|
||||
hasLocation(#20373,#20374)
|
||||
successor(#20301,#20373)
|
||||
successor(#20298,#20301)
|
||||
successor(#20371,#20298)
|
||||
successor(#20294,#20295)
|
||||
successor(#20292,#20310)
|
||||
successor(#20282,#20294)
|
||||
successor(#20272,#20282)
|
||||
successor(#20266,#20272)
|
||||
successor(#20264,#20266)
|
||||
successor(#20262,#20314)
|
||||
successor(#20258,#20264)
|
||||
successor(#20366,#20258)
|
||||
numlines(#10000,29,15,8)
|
||||
filetype(#10000,"typescript")
|
||||
|
||||
@@ -425,146 +425,146 @@ hasLocation(#20001,#20158)
|
||||
variables(#20159,"declaration",#20000)
|
||||
#20160=@"var;{f};{#20000}"
|
||||
variables(#20160,"f",#20000)
|
||||
#20161=@"var;{C};{#20000}"
|
||||
variables(#20161,"C",#20000)
|
||||
#20162=@"local_type_name;{C};{#20000}"
|
||||
local_type_names(#20162,"C",#20000)
|
||||
#20163=@"local_type_name;{I};{#20000}"
|
||||
local_type_names(#20163,"I",#20000)
|
||||
#20164=*
|
||||
stmts(#20164,17,#20001,0,"functio ... ber) {}")
|
||||
hasLocation(#20164,#20003)
|
||||
stmt_containers(#20164,#20001)
|
||||
#20161=@"var;{ambient};{#20000}"
|
||||
variables(#20161,"ambient",#20000)
|
||||
#20162=@"var;{C};{#20000}"
|
||||
variables(#20162,"C",#20000)
|
||||
#20163=@"local_type_name;{C};{#20000}"
|
||||
local_type_names(#20163,"C",#20000)
|
||||
#20164=@"local_type_name;{I};{#20000}"
|
||||
local_type_names(#20164,"I",#20000)
|
||||
#20165=*
|
||||
exprs(#20165,78,#20164,-1,"declaration")
|
||||
hasLocation(#20165,#20033)
|
||||
expr_containers(#20165,#20164)
|
||||
literals("declaration","declaration",#20165)
|
||||
decl(#20165,#20159)
|
||||
stmts(#20165,17,#20001,0,"functio ... ber) {}")
|
||||
hasLocation(#20165,#20003)
|
||||
stmt_containers(#20165,#20001)
|
||||
#20166=*
|
||||
scopes(#20166,1)
|
||||
scopenodes(#20164,#20166)
|
||||
scopenesting(#20166,#20000)
|
||||
#20167=@"var;{x};{#20166}"
|
||||
variables(#20167,"x",#20166)
|
||||
#20168=*
|
||||
exprs(#20168,78,#20164,0,"x")
|
||||
hasLocation(#20168,#20045)
|
||||
expr_containers(#20168,#20164)
|
||||
literals("x","x",#20168)
|
||||
decl(#20168,#20167)
|
||||
#20169=@"var;{arguments};{#20166}"
|
||||
variables(#20169,"arguments",#20166)
|
||||
is_arguments_object(#20169)
|
||||
#20170=*
|
||||
typeexprs(#20170,2,#20164,-4,"void")
|
||||
hasLocation(#20170,#20041)
|
||||
expr_containers(#20170,#20164)
|
||||
literals("void","void",#20170)
|
||||
exprs(#20166,78,#20165,-1,"declaration")
|
||||
hasLocation(#20166,#20033)
|
||||
expr_containers(#20166,#20165)
|
||||
literals("declaration","declaration",#20166)
|
||||
decl(#20166,#20159)
|
||||
#20167=*
|
||||
scopes(#20167,1)
|
||||
scopenodes(#20165,#20167)
|
||||
scopenesting(#20167,#20000)
|
||||
#20168=@"var;{x};{#20167}"
|
||||
variables(#20168,"x",#20167)
|
||||
#20169=*
|
||||
exprs(#20169,78,#20165,0,"x")
|
||||
hasLocation(#20169,#20045)
|
||||
expr_containers(#20169,#20165)
|
||||
literals("x","x",#20169)
|
||||
decl(#20169,#20168)
|
||||
#20170=@"var;{arguments};{#20167}"
|
||||
variables(#20170,"arguments",#20167)
|
||||
is_arguments_object(#20170)
|
||||
#20171=*
|
||||
typeexprs(#20171,2,#20164,-6,"number")
|
||||
hasLocation(#20171,#20049)
|
||||
expr_containers(#20171,#20164)
|
||||
literals("number","number",#20171)
|
||||
typeexprs(#20171,2,#20165,-4,"void")
|
||||
hasLocation(#20171,#20041)
|
||||
expr_containers(#20171,#20165)
|
||||
literals("void","void",#20171)
|
||||
#20172=*
|
||||
stmts(#20172,1,#20164,-2,"{}")
|
||||
#20173=@"loc,{#10000},1,45,1,46"
|
||||
locations_default(#20173,#10000,1,45,1,46)
|
||||
hasLocation(#20172,#20173)
|
||||
stmt_containers(#20172,#20164)
|
||||
#20174=*
|
||||
stmts(#20174,18,#20001,1,"var f = ... ber) {}")
|
||||
hasLocation(#20174,#20007)
|
||||
stmt_containers(#20174,#20001)
|
||||
typeexprs(#20172,2,#20165,-6,"number")
|
||||
hasLocation(#20172,#20049)
|
||||
expr_containers(#20172,#20165)
|
||||
literals("number","number",#20172)
|
||||
#20173=*
|
||||
stmts(#20173,1,#20165,-2,"{}")
|
||||
#20174=@"loc,{#10000},1,45,1,46"
|
||||
locations_default(#20174,#10000,1,45,1,46)
|
||||
hasLocation(#20173,#20174)
|
||||
stmt_containers(#20173,#20165)
|
||||
#20175=*
|
||||
exprs(#20175,64,#20174,0,"f = fun ... ber) {}")
|
||||
#20176=@"loc,{#10000},3,5,3,44"
|
||||
locations_default(#20176,#10000,3,5,3,44)
|
||||
hasLocation(#20175,#20176)
|
||||
enclosing_stmt(#20175,#20174)
|
||||
expr_containers(#20175,#20001)
|
||||
#20177=*
|
||||
exprs(#20177,78,#20175,0,"f")
|
||||
hasLocation(#20177,#20059)
|
||||
enclosing_stmt(#20177,#20174)
|
||||
expr_containers(#20177,#20001)
|
||||
literals("f","f",#20177)
|
||||
decl(#20177,#20160)
|
||||
stmts(#20175,18,#20001,1,"var f = ... ber) {}")
|
||||
hasLocation(#20175,#20007)
|
||||
stmt_containers(#20175,#20001)
|
||||
#20176=*
|
||||
exprs(#20176,64,#20175,0,"f = fun ... ber) {}")
|
||||
#20177=@"loc,{#10000},3,5,3,44"
|
||||
locations_default(#20177,#10000,3,5,3,44)
|
||||
hasLocation(#20176,#20177)
|
||||
enclosing_stmt(#20176,#20175)
|
||||
expr_containers(#20176,#20001)
|
||||
#20178=*
|
||||
exprs(#20178,9,#20175,1,"functio ... ber) {}")
|
||||
#20179=@"loc,{#10000},3,9,3,44"
|
||||
locations_default(#20179,#10000,3,9,3,44)
|
||||
hasLocation(#20178,#20179)
|
||||
enclosing_stmt(#20178,#20174)
|
||||
exprs(#20178,78,#20176,0,"f")
|
||||
hasLocation(#20178,#20059)
|
||||
enclosing_stmt(#20178,#20175)
|
||||
expr_containers(#20178,#20001)
|
||||
#20180=*
|
||||
scopes(#20180,1)
|
||||
scopenodes(#20178,#20180)
|
||||
scopenesting(#20180,#20000)
|
||||
#20181=@"var;{x};{#20180}"
|
||||
variables(#20181,"x",#20180)
|
||||
#20182=*
|
||||
exprs(#20182,78,#20178,0,"x")
|
||||
hasLocation(#20182,#20075)
|
||||
expr_containers(#20182,#20178)
|
||||
literals("x","x",#20182)
|
||||
decl(#20182,#20181)
|
||||
#20183=@"var;{arguments};{#20180}"
|
||||
variables(#20183,"arguments",#20180)
|
||||
is_arguments_object(#20183)
|
||||
#20184=*
|
||||
typeexprs(#20184,2,#20178,-4,"string")
|
||||
hasLocation(#20184,#20071)
|
||||
expr_containers(#20184,#20178)
|
||||
literals("string","string",#20184)
|
||||
literals("f","f",#20178)
|
||||
decl(#20178,#20160)
|
||||
#20179=*
|
||||
exprs(#20179,9,#20176,1,"functio ... ber) {}")
|
||||
#20180=@"loc,{#10000},3,9,3,44"
|
||||
locations_default(#20180,#10000,3,9,3,44)
|
||||
hasLocation(#20179,#20180)
|
||||
enclosing_stmt(#20179,#20175)
|
||||
expr_containers(#20179,#20001)
|
||||
#20181=*
|
||||
scopes(#20181,1)
|
||||
scopenodes(#20179,#20181)
|
||||
scopenesting(#20181,#20000)
|
||||
#20182=@"var;{x};{#20181}"
|
||||
variables(#20182,"x",#20181)
|
||||
#20183=*
|
||||
exprs(#20183,78,#20179,0,"x")
|
||||
hasLocation(#20183,#20075)
|
||||
expr_containers(#20183,#20179)
|
||||
literals("x","x",#20183)
|
||||
decl(#20183,#20182)
|
||||
#20184=@"var;{arguments};{#20181}"
|
||||
variables(#20184,"arguments",#20181)
|
||||
is_arguments_object(#20184)
|
||||
#20185=*
|
||||
typeexprs(#20185,2,#20178,-6,"number")
|
||||
hasLocation(#20185,#20079)
|
||||
expr_containers(#20185,#20178)
|
||||
literals("number","number",#20185)
|
||||
typeexprs(#20185,2,#20179,-4,"string")
|
||||
hasLocation(#20185,#20071)
|
||||
expr_containers(#20185,#20179)
|
||||
literals("string","string",#20185)
|
||||
#20186=*
|
||||
stmts(#20186,1,#20178,-2,"{}")
|
||||
#20187=@"loc,{#10000},3,43,3,44"
|
||||
locations_default(#20187,#10000,3,43,3,44)
|
||||
hasLocation(#20186,#20187)
|
||||
stmt_containers(#20186,#20178)
|
||||
#20188=*
|
||||
stmts(#20188,17,#20001,2,"declare ... umber);")
|
||||
hasLocation(#20188,#20011)
|
||||
stmt_containers(#20188,#20001)
|
||||
has_declare_keyword(#20188)
|
||||
typeexprs(#20186,2,#20179,-6,"number")
|
||||
hasLocation(#20186,#20079)
|
||||
expr_containers(#20186,#20179)
|
||||
literals("number","number",#20186)
|
||||
#20187=*
|
||||
stmts(#20187,1,#20179,-2,"{}")
|
||||
#20188=@"loc,{#10000},3,43,3,44"
|
||||
locations_default(#20188,#10000,3,43,3,44)
|
||||
hasLocation(#20187,#20188)
|
||||
stmt_containers(#20187,#20179)
|
||||
#20189=*
|
||||
exprs(#20189,78,#20188,-1,"ambient")
|
||||
hasLocation(#20189,#20091)
|
||||
expr_containers(#20189,#20188)
|
||||
literals("ambient","ambient",#20189)
|
||||
#20190=@"var;{ambient};{#20000}"
|
||||
variables(#20190,"ambient",#20000)
|
||||
decl(#20189,#20190)
|
||||
stmts(#20189,17,#20001,2,"declare ... umber);")
|
||||
hasLocation(#20189,#20011)
|
||||
stmt_containers(#20189,#20001)
|
||||
has_declare_keyword(#20189)
|
||||
#20190=*
|
||||
exprs(#20190,78,#20189,-1,"ambient")
|
||||
hasLocation(#20190,#20091)
|
||||
expr_containers(#20190,#20189)
|
||||
literals("ambient","ambient",#20190)
|
||||
decl(#20190,#20161)
|
||||
#20191=*
|
||||
scopes(#20191,1)
|
||||
scopenodes(#20188,#20191)
|
||||
scopenodes(#20189,#20191)
|
||||
scopenesting(#20191,#20000)
|
||||
#20192=@"var;{x};{#20191}"
|
||||
variables(#20192,"x",#20191)
|
||||
#20193=*
|
||||
exprs(#20193,78,#20188,0,"x")
|
||||
exprs(#20193,78,#20189,0,"x")
|
||||
hasLocation(#20193,#20103)
|
||||
expr_containers(#20193,#20188)
|
||||
expr_containers(#20193,#20189)
|
||||
literals("x","x",#20193)
|
||||
decl(#20193,#20192)
|
||||
#20194=@"var;{arguments};{#20191}"
|
||||
variables(#20194,"arguments",#20191)
|
||||
is_arguments_object(#20194)
|
||||
#20195=*
|
||||
typeexprs(#20195,2,#20188,-4,"string")
|
||||
typeexprs(#20195,2,#20189,-4,"string")
|
||||
hasLocation(#20195,#20099)
|
||||
expr_containers(#20195,#20188)
|
||||
expr_containers(#20195,#20189)
|
||||
literals("string","string",#20195)
|
||||
#20196=*
|
||||
typeexprs(#20196,2,#20188,-6,"number")
|
||||
typeexprs(#20196,2,#20189,-6,"number")
|
||||
hasLocation(#20196,#20107)
|
||||
expr_containers(#20196,#20188)
|
||||
expr_containers(#20196,#20189)
|
||||
literals("number","number",#20196)
|
||||
#20197=*
|
||||
stmts(#20197,26,#20001,3,"class C ... C) {}\n}")
|
||||
@@ -578,8 +578,8 @@ hasLocation(#20199,#20115)
|
||||
enclosing_stmt(#20199,#20197)
|
||||
expr_containers(#20199,#20001)
|
||||
literals("C","C",#20199)
|
||||
decl(#20199,#20161)
|
||||
typedecl(#20199,#20162)
|
||||
decl(#20199,#20162)
|
||||
typedecl(#20199,#20163)
|
||||
#20200=*
|
||||
scopes(#20200,10)
|
||||
scopenodes(#20197,#20200)
|
||||
@@ -612,7 +612,7 @@ typeexprs(#20207,0,#20204,-4,"C")
|
||||
hasLocation(#20207,#20127)
|
||||
expr_containers(#20207,#20204)
|
||||
literals("C","C",#20207)
|
||||
typebind(#20207,#20162)
|
||||
typebind(#20207,#20163)
|
||||
#20208=*
|
||||
stmts(#20208,1,#20204,-2,"{}")
|
||||
#20209=@"loc,{#10000},8,19,8,20"
|
||||
@@ -660,7 +660,7 @@ hasLocation(#20219,#20138)
|
||||
enclosing_stmt(#20219,#20217)
|
||||
expr_containers(#20219,#20001)
|
||||
literals("I","I",#20219)
|
||||
typedecl(#20219,#20163)
|
||||
typedecl(#20219,#20164)
|
||||
#20220=*
|
||||
properties(#20220,#20217,2,0,"method(this: I);")
|
||||
#20221=@"loc,{#10000},12,3,12,18"
|
||||
@@ -689,7 +689,7 @@ typeexprs(#20226,0,#20223,-4,"I")
|
||||
hasLocation(#20226,#20150)
|
||||
expr_containers(#20226,#20223)
|
||||
literals("I","I",#20226)
|
||||
typebind(#20226,#20163)
|
||||
typebind(#20226,#20164)
|
||||
is_method(#20220)
|
||||
is_abstract_member(#20220)
|
||||
#20227=*
|
||||
@@ -729,37 +729,37 @@ successor(#20203,#20204)
|
||||
successor(#20201,#20212)
|
||||
successor(#20199,#20203)
|
||||
successor(#20197,#20217)
|
||||
successor(#20188,#20199)
|
||||
successor(#20174,#20177)
|
||||
successor(#20178,#20175)
|
||||
successor(#20189,#20199)
|
||||
successor(#20175,#20178)
|
||||
successor(#20179,#20176)
|
||||
#20236=*
|
||||
entry_cfg_node(#20236,#20178)
|
||||
entry_cfg_node(#20236,#20179)
|
||||
#20237=@"loc,{#10000},3,9,3,8"
|
||||
locations_default(#20237,#10000,3,9,3,8)
|
||||
hasLocation(#20236,#20237)
|
||||
#20238=*
|
||||
exit_cfg_node(#20238,#20178)
|
||||
exit_cfg_node(#20238,#20179)
|
||||
#20239=@"loc,{#10000},3,45,3,44"
|
||||
locations_default(#20239,#10000,3,45,3,44)
|
||||
hasLocation(#20238,#20239)
|
||||
successor(#20186,#20238)
|
||||
successor(#20182,#20186)
|
||||
successor(#20236,#20182)
|
||||
successor(#20177,#20178)
|
||||
successor(#20175,#20188)
|
||||
successor(#20164,#20174)
|
||||
successor(#20187,#20238)
|
||||
successor(#20183,#20187)
|
||||
successor(#20236,#20183)
|
||||
successor(#20178,#20179)
|
||||
successor(#20176,#20189)
|
||||
successor(#20165,#20175)
|
||||
#20240=*
|
||||
entry_cfg_node(#20240,#20164)
|
||||
entry_cfg_node(#20240,#20165)
|
||||
hasLocation(#20240,#20228)
|
||||
#20241=*
|
||||
exit_cfg_node(#20241,#20164)
|
||||
exit_cfg_node(#20241,#20165)
|
||||
#20242=@"loc,{#10000},1,47,1,46"
|
||||
locations_default(#20242,#10000,1,47,1,46)
|
||||
hasLocation(#20241,#20242)
|
||||
successor(#20172,#20241)
|
||||
successor(#20168,#20172)
|
||||
successor(#20240,#20168)
|
||||
successor(#20165,#20164)
|
||||
successor(#20227,#20165)
|
||||
successor(#20173,#20241)
|
||||
successor(#20169,#20173)
|
||||
successor(#20240,#20169)
|
||||
successor(#20166,#20165)
|
||||
successor(#20227,#20166)
|
||||
numlines(#10000,14,9,0)
|
||||
filetype(#10000,"typescript")
|
||||
|
||||
Reference in New Issue
Block a user