diff --git a/javascript/extractor/src/com/semmle/js/extractor/AutoBuild.java b/javascript/extractor/src/com/semmle/js/extractor/AutoBuild.java index 22d008637c9a..c5f88379fd31 100644 --- a/javascript/extractor/src/com/semmle/js/extractor/AutoBuild.java +++ b/javascript/extractor/src/com/semmle/js/extractor/AutoBuild.java @@ -237,7 +237,7 @@ public AutoBuild() { this.outputConfig = new ExtractorOutputConfig(LegacyLanguage.JAVASCRIPT); this.trapCache = ITrapCache.fromExtractorOptions(); this.typeScriptMode = - getEnumFromEnvVar("LGTM_INDEX_TYPESCRIPT", TypeScriptMode.class, TypeScriptMode.FULL); + getEnumFromEnvVar("LGTM_INDEX_TYPESCRIPT", TypeScriptMode.class, TypeScriptMode.BASIC); this.defaultEncoding = getEnvVar("LGTM_INDEX_DEFAULT_ENCODING"); this.installDependencies = Boolean.valueOf(getEnvVar("LGTM_INDEX_TYPESCRIPT_INSTALL_DEPS")); this.virtualSourceRoot = makeVirtualSourceRoot(); diff --git a/javascript/extractor/src/com/semmle/js/extractor/ScopeManager.java b/javascript/extractor/src/com/semmle/js/extractor/ScopeManager.java index e7306e77e016..43e70160fe8f 100644 --- a/javascript/extractor/src/com/semmle/js/extractor/ScopeManager.java +++ b/javascript/extractor/src/com/semmle/js/extractor/ScopeManager.java @@ -426,7 +426,6 @@ public Void visit(Identifier nd, Void v) { // cases where we turn on the 'declKind' flags @Override public Void visit(FunctionDeclaration nd, Void v) { - if (nd.hasDeclareKeyword() && !isInTypeScriptDeclarationFile()) return null; // strict mode functions are block-scoped, non-strict mode ones aren't if (blockscope == isStrict) visit(nd.getId(), DeclKind.var); return null; @@ -434,7 +433,6 @@ public Void visit(FunctionDeclaration nd, Void v) { @Override public Void visit(ClassDeclaration nd, Void c) { - if (nd.hasDeclareKeyword() && !isInTypeScriptDeclarationFile()) return null; if (blockscope) visit(nd.getClassDef().getId(), DeclKind.varAndType); return null; } @@ -483,7 +481,6 @@ public Void visit(EnhancedForStatement nd, Void v) { @Override public Void visit(VariableDeclaration nd, Void v) { - if (nd.hasDeclareKeyword() && !isInTypeScriptDeclarationFile()) return null; // in block scoping mode, only process 'let'; in non-block scoping // mode, only process non-'let' if (blockscope == nd.isBlockScoped(ecmaVersion)) visit(nd.getDeclarations()); @@ -518,8 +515,7 @@ public Void visit(ClassBody nd, Void c) { @Override public Void visit(NamespaceDeclaration nd, Void c) { if (blockscope) return null; - boolean isAmbientOutsideDtsFile = nd.hasDeclareKeyword() && !isInTypeScriptDeclarationFile(); - boolean hasVariable = nd.isInstantiated() && !isAmbientOutsideDtsFile; + boolean hasVariable = nd.isInstantiated(); visit(nd.getName(), hasVariable ? DeclKind.varAndNamespace : DeclKind.namespace); return null; } diff --git a/javascript/extractor/tests/ts/output/trap/conditionalTypes.ts.trap b/javascript/extractor/tests/ts/output/trap/conditionalTypes.ts.trap index 0751d283e6cc..2a1c0efbd441 100644 --- a/javascript/extractor/tests/ts/output/trap/conditionalTypes.ts.trap +++ b/javascript/extractor/tests/ts/output/trap/conditionalTypes.ts.trap @@ -8434,1316 +8434,1316 @@ namespacedecl(#22807,#22182) scopes(#22808,9) scopenodes(#22805,#22808) scopenesting(#22808,#20000) -#22809=@"local_type_name;{Unpacked};{#22808}" -local_type_names(#22809,"Unpacked",#22808) -#22810=@"local_type_name;{T0};{#22808}" -local_type_names(#22810,"T0",#22808) -#22811=@"local_type_name;{T1};{#22808}" -local_type_names(#22811,"T1",#22808) -#22812=@"local_type_name;{T2};{#22808}" -local_type_names(#22812,"T2",#22808) -#22813=@"local_type_name;{T3};{#22808}" -local_type_names(#22813,"T3",#22808) -#22814=@"local_type_name;{T4};{#22808}" -local_type_names(#22814,"T4",#22808) -#22815=@"local_type_name;{T5};{#22808}" -local_type_names(#22815,"T5",#22808) -#22816=@"local_type_name;{Foo};{#22808}" -local_type_names(#22816,"Foo",#22808) -#22817=@"local_type_name;{T10};{#22808}" -local_type_names(#22817,"T10",#22808) -#22818=@"local_type_name;{T11};{#22808}" -local_type_names(#22818,"T11",#22808) -#22819=@"local_type_name;{Bar};{#22808}" -local_type_names(#22819,"Bar",#22808) -#22820=@"local_type_name;{T20};{#22808}" -local_type_names(#22820,"T20",#22808) -#22821=@"local_type_name;{T21};{#22808}" -local_type_names(#22821,"T21",#22808) -#22822=@"local_type_name;{T30};{#22808}" -local_type_names(#22822,"T30",#22808) -#22823=@"local_type_name;{AnyFunction};{#22808}" -local_type_names(#22823,"AnyFunction",#22808) -#22824=@"local_type_name;{ReturnType};{#22808}" -local_type_names(#22824,"ReturnType",#22808) -#22825=* -stmts(#22825,35,#22805,0,"type Un ... \n T;") -#22826=@"loc,{#10000},73,3,77,6" -locations_default(#22826,#10000,73,3,77,6) -hasLocation(#22825,#22826) -stmt_containers(#22825,#22805) -#22827=* -typeexprs(#22827,1,#22825,0,"Unpacked") -hasLocation(#22827,#21482) -enclosing_stmt(#22827,#22825) -expr_containers(#22827,#22805) -literals("Unpacked","Unpacked",#22827) -typedecl(#22827,#22809) +#22809=@"var;{foo};{#22808}" +variables(#22809,"foo",#22808) +#22810=@"local_type_name;{Unpacked};{#22808}" +local_type_names(#22810,"Unpacked",#22808) +#22811=@"local_type_name;{T0};{#22808}" +local_type_names(#22811,"T0",#22808) +#22812=@"local_type_name;{T1};{#22808}" +local_type_names(#22812,"T1",#22808) +#22813=@"local_type_name;{T2};{#22808}" +local_type_names(#22813,"T2",#22808) +#22814=@"local_type_name;{T3};{#22808}" +local_type_names(#22814,"T3",#22808) +#22815=@"local_type_name;{T4};{#22808}" +local_type_names(#22815,"T4",#22808) +#22816=@"local_type_name;{T5};{#22808}" +local_type_names(#22816,"T5",#22808) +#22817=@"local_type_name;{Foo};{#22808}" +local_type_names(#22817,"Foo",#22808) +#22818=@"local_type_name;{T10};{#22808}" +local_type_names(#22818,"T10",#22808) +#22819=@"local_type_name;{T11};{#22808}" +local_type_names(#22819,"T11",#22808) +#22820=@"local_type_name;{Bar};{#22808}" +local_type_names(#22820,"Bar",#22808) +#22821=@"local_type_name;{T20};{#22808}" +local_type_names(#22821,"T20",#22808) +#22822=@"local_type_name;{T21};{#22808}" +local_type_names(#22822,"T21",#22808) +#22823=@"local_type_name;{T30};{#22808}" +local_type_names(#22823,"T30",#22808) +#22824=@"local_type_name;{AnyFunction};{#22808}" +local_type_names(#22824,"AnyFunction",#22808) +#22825=@"local_type_name;{ReturnType};{#22808}" +local_type_names(#22825,"ReturnType",#22808) +#22826=* +stmts(#22826,35,#22805,0,"type Un ... \n T;") +#22827=@"loc,{#10000},73,3,77,6" +locations_default(#22827,#10000,73,3,77,6) +hasLocation(#22826,#22827) +stmt_containers(#22826,#22805) #22828=* -scopes(#22828,12) -scopenodes(#22825,#22828) -scopenesting(#22828,#22808) -#22829=@"local_type_name;{T};{#22828}" -local_type_names(#22829,"T",#22828) -#22830=* -typeexprs(#22830,22,#22825,2,"T") -hasLocation(#22830,#21486) -enclosing_stmt(#22830,#22825) -expr_containers(#22830,#22805) +typeexprs(#22828,1,#22826,0,"Unpacked") +hasLocation(#22828,#21482) +enclosing_stmt(#22828,#22826) +expr_containers(#22828,#22805) +literals("Unpacked","Unpacked",#22828) +typedecl(#22828,#22810) +#22829=* +scopes(#22829,12) +scopenodes(#22826,#22829) +scopenesting(#22829,#22808) +#22830=@"local_type_name;{T};{#22829}" +local_type_names(#22830,"T",#22829) #22831=* -typeexprs(#22831,1,#22830,0,"T") +typeexprs(#22831,22,#22826,2,"T") hasLocation(#22831,#21486) -enclosing_stmt(#22831,#22825) +enclosing_stmt(#22831,#22826) expr_containers(#22831,#22805) -literals("T","T",#22831) -typedecl(#22831,#22829) #22832=* -typeexprs(#22832,28,#22825,1,"T exten ... :\n T") -#22833=@"loc,{#10000},74,5,77,5" -locations_default(#22833,#10000,74,5,77,5) -hasLocation(#22832,#22833) -enclosing_stmt(#22832,#22825) +typeexprs(#22832,1,#22831,0,"T") +hasLocation(#22832,#21486) +enclosing_stmt(#22832,#22826) expr_containers(#22832,#22805) -#22834=* -typeexprs(#22834,0,#22832,0,"T") -hasLocation(#22834,#21492) -enclosing_stmt(#22834,#22825) -expr_containers(#22834,#22805) -literals("T","T",#22834) -typebind(#22834,#22829) +literals("T","T",#22832) +typedecl(#22832,#22830) +#22833=* +typeexprs(#22833,28,#22826,1,"T exten ... :\n T") +#22834=@"loc,{#10000},74,5,77,5" +locations_default(#22834,#10000,74,5,77,5) +hasLocation(#22833,#22834) +enclosing_stmt(#22833,#22826) +expr_containers(#22833,#22805) #22835=* -scopes(#22835,16) -scopenodes(#22832,#22835) -scopenesting(#22835,#22828) -#22836=@"local_type_name;{U};{#22835}" -local_type_names(#22836,"U",#22835) -#22837=* -typeexprs(#22837,6,#22832,1,"(infer U)[]") -#22838=@"loc,{#10000},74,15,74,25" -locations_default(#22838,#10000,74,15,74,25) -hasLocation(#22837,#22838) -enclosing_stmt(#22837,#22825) -expr_containers(#22837,#22805) -#22839=* -typeexprs(#22839,10,#22837,0,"(infer U)") -#22840=@"loc,{#10000},74,15,74,23" -locations_default(#22840,#10000,74,15,74,23) -hasLocation(#22839,#22840) -enclosing_stmt(#22839,#22825) -expr_containers(#22839,#22805) -#22841=* -typeexprs(#22841,29,#22839,0,"infer U") -#22842=@"loc,{#10000},74,16,74,22" -locations_default(#22842,#10000,74,16,74,22) -hasLocation(#22841,#22842) -enclosing_stmt(#22841,#22825) -expr_containers(#22841,#22805) -#22843=* -typeexprs(#22843,22,#22841,0,"U") -hasLocation(#22843,#21500) -enclosing_stmt(#22843,#22825) -expr_containers(#22843,#22805) +typeexprs(#22835,0,#22833,0,"T") +hasLocation(#22835,#21492) +enclosing_stmt(#22835,#22826) +expr_containers(#22835,#22805) +literals("T","T",#22835) +typebind(#22835,#22830) +#22836=* +scopes(#22836,16) +scopenodes(#22833,#22836) +scopenesting(#22836,#22829) +#22837=@"local_type_name;{U};{#22836}" +local_type_names(#22837,"U",#22836) +#22838=* +typeexprs(#22838,6,#22833,1,"(infer U)[]") +#22839=@"loc,{#10000},74,15,74,25" +locations_default(#22839,#10000,74,15,74,25) +hasLocation(#22838,#22839) +enclosing_stmt(#22838,#22826) +expr_containers(#22838,#22805) +#22840=* +typeexprs(#22840,10,#22838,0,"(infer U)") +#22841=@"loc,{#10000},74,15,74,23" +locations_default(#22841,#10000,74,15,74,23) +hasLocation(#22840,#22841) +enclosing_stmt(#22840,#22826) +expr_containers(#22840,#22805) +#22842=* +typeexprs(#22842,29,#22840,0,"infer U") +#22843=@"loc,{#10000},74,16,74,22" +locations_default(#22843,#10000,74,16,74,22) +hasLocation(#22842,#22843) +enclosing_stmt(#22842,#22826) +expr_containers(#22842,#22805) #22844=* -typeexprs(#22844,1,#22843,0,"U") +typeexprs(#22844,22,#22842,0,"U") hasLocation(#22844,#21500) -enclosing_stmt(#22844,#22825) +enclosing_stmt(#22844,#22826) expr_containers(#22844,#22805) -literals("U","U",#22844) -typedecl(#22844,#22836) #22845=* -typeexprs(#22845,0,#22832,2,"U") -hasLocation(#22845,#21510) -enclosing_stmt(#22845,#22825) +typeexprs(#22845,1,#22844,0,"U") +hasLocation(#22845,#21500) +enclosing_stmt(#22845,#22826) expr_containers(#22845,#22805) literals("U","U",#22845) -typebind(#22845,#22836) +typedecl(#22845,#22837) #22846=* -typeexprs(#22846,28,#22832,3,"T exten ... :\n T") -#22847=@"loc,{#10000},75,5,77,5" -locations_default(#22847,#10000,75,5,77,5) -hasLocation(#22846,#22847) -enclosing_stmt(#22846,#22825) +typeexprs(#22846,0,#22833,2,"U") +hasLocation(#22846,#21510) +enclosing_stmt(#22846,#22826) expr_containers(#22846,#22805) -#22848=* -typeexprs(#22848,0,#22846,0,"T") -hasLocation(#22848,#21514) -enclosing_stmt(#22848,#22825) -expr_containers(#22848,#22805) -literals("T","T",#22848) -typebind(#22848,#22829) +literals("U","U",#22846) +typebind(#22846,#22837) +#22847=* +typeexprs(#22847,28,#22833,3,"T exten ... :\n T") +#22848=@"loc,{#10000},75,5,77,5" +locations_default(#22848,#10000,75,5,77,5) +hasLocation(#22847,#22848) +enclosing_stmt(#22847,#22826) +expr_containers(#22847,#22805) #22849=* -scopes(#22849,16) -scopenodes(#22846,#22849) -scopenesting(#22849,#22828) -#22850=@"local_type_name;{U};{#22849}" -local_type_names(#22850,"U",#22849) -#22851=* -typeexprs(#22851,23,#22846,1,"(...arg ... infer U") -#22852=@"loc,{#10000},75,15,75,41" -locations_default(#22852,#10000,75,15,75,41) -hasLocation(#22851,#22852) -enclosing_stmt(#22851,#22825) -expr_containers(#22851,#22805) -#22853=* -exprs(#22853,9,#22851,0,"(...arg ... infer U") -hasLocation(#22853,#22852) -enclosing_stmt(#22853,#22825) -expr_containers(#22853,#22805) +typeexprs(#22849,0,#22847,0,"T") +hasLocation(#22849,#21514) +enclosing_stmt(#22849,#22826) +expr_containers(#22849,#22805) +literals("T","T",#22849) +typebind(#22849,#22830) +#22850=* +scopes(#22850,16) +scopenodes(#22847,#22850) +scopenesting(#22850,#22829) +#22851=@"local_type_name;{U};{#22850}" +local_type_names(#22851,"U",#22850) +#22852=* +typeexprs(#22852,23,#22847,1,"(...arg ... infer U") +#22853=@"loc,{#10000},75,15,75,41" +locations_default(#22853,#10000,75,15,75,41) +hasLocation(#22852,#22853) +enclosing_stmt(#22852,#22826) +expr_containers(#22852,#22805) #22854=* -scopes(#22854,1) -scopenodes(#22853,#22854) -scopenesting(#22854,#22849) -#22855=@"var;{args};{#22854}" -variables(#22855,"args",#22854) -#22856=* -exprs(#22856,78,#22853,0,"args") -hasLocation(#22856,#21522) -expr_containers(#22856,#22853) -literals("args","args",#22856) -decl(#22856,#22855) -#22857=@"var;{arguments};{#22854}" -variables(#22857,"arguments",#22854) -is_arguments_object(#22857) -#22858=* -typeexprs(#22858,29,#22853,-3,"infer U") -#22859=@"loc,{#10000},75,35,75,41" -locations_default(#22859,#10000,75,35,75,41) -hasLocation(#22858,#22859) -expr_containers(#22858,#22853) -#22860=* -typeexprs(#22860,22,#22858,0,"U") -hasLocation(#22860,#21538) -expr_containers(#22860,#22853) +exprs(#22854,9,#22852,0,"(...arg ... infer U") +hasLocation(#22854,#22853) +enclosing_stmt(#22854,#22826) +expr_containers(#22854,#22805) +#22855=* +scopes(#22855,1) +scopenodes(#22854,#22855) +scopenesting(#22855,#22850) +#22856=@"var;{args};{#22855}" +variables(#22856,"args",#22855) +#22857=* +exprs(#22857,78,#22854,0,"args") +hasLocation(#22857,#21522) +expr_containers(#22857,#22854) +literals("args","args",#22857) +decl(#22857,#22856) +#22858=@"var;{arguments};{#22855}" +variables(#22858,"arguments",#22855) +is_arguments_object(#22858) +#22859=* +typeexprs(#22859,29,#22854,-3,"infer U") +#22860=@"loc,{#10000},75,35,75,41" +locations_default(#22860,#10000,75,35,75,41) +hasLocation(#22859,#22860) +expr_containers(#22859,#22854) #22861=* -typeexprs(#22861,1,#22860,0,"U") +typeexprs(#22861,22,#22859,0,"U") hasLocation(#22861,#21538) -expr_containers(#22861,#22853) -literals("U","U",#22861) -typedecl(#22861,#22850) +expr_containers(#22861,#22854) #22862=* -typeexprs(#22862,6,#22853,-6,"any[]") -#22863=@"loc,{#10000},75,25,75,29" -locations_default(#22863,#10000,75,25,75,29) -hasLocation(#22862,#22863) -expr_containers(#22862,#22853) -#22864=* -typeexprs(#22864,2,#22862,0,"any") -hasLocation(#22864,#21526) -expr_containers(#22864,#22853) -literals("any","any",#22864) -has_rest_parameter(#22853) +typeexprs(#22862,1,#22861,0,"U") +hasLocation(#22862,#21538) +expr_containers(#22862,#22854) +literals("U","U",#22862) +typedecl(#22862,#22851) +#22863=* +typeexprs(#22863,6,#22854,-6,"any[]") +#22864=@"loc,{#10000},75,25,75,29" +locations_default(#22864,#10000,75,25,75,29) +hasLocation(#22863,#22864) +expr_containers(#22863,#22854) #22865=* -typeexprs(#22865,0,#22846,2,"U") -hasLocation(#22865,#21542) -enclosing_stmt(#22865,#22825) -expr_containers(#22865,#22805) -literals("U","U",#22865) -typebind(#22865,#22850) +typeexprs(#22865,2,#22863,0,"any") +hasLocation(#22865,#21526) +expr_containers(#22865,#22854) +literals("any","any",#22865) +has_rest_parameter(#22854) #22866=* -typeexprs(#22866,28,#22846,3,"T exten ... :\n T") -#22867=@"loc,{#10000},76,5,77,5" -locations_default(#22867,#10000,76,5,77,5) -hasLocation(#22866,#22867) -enclosing_stmt(#22866,#22825) +typeexprs(#22866,0,#22847,2,"U") +hasLocation(#22866,#21542) +enclosing_stmt(#22866,#22826) expr_containers(#22866,#22805) -#22868=* -typeexprs(#22868,0,#22866,0,"T") -hasLocation(#22868,#21546) -enclosing_stmt(#22868,#22825) -expr_containers(#22868,#22805) -literals("T","T",#22868) -typebind(#22868,#22829) +literals("U","U",#22866) +typebind(#22866,#22851) +#22867=* +typeexprs(#22867,28,#22847,3,"T exten ... :\n T") +#22868=@"loc,{#10000},76,5,77,5" +locations_default(#22868,#10000,76,5,77,5) +hasLocation(#22867,#22868) +enclosing_stmt(#22867,#22826) +expr_containers(#22867,#22805) #22869=* -scopes(#22869,16) -scopenodes(#22866,#22869) -scopenesting(#22869,#22828) -#22870=@"local_type_name;{U};{#22869}" -local_type_names(#22870,"U",#22869) -#22871=* -typeexprs(#22871,14,#22866,1,"Promise") -#22872=@"loc,{#10000},76,15,76,30" -locations_default(#22872,#10000,76,15,76,30) -hasLocation(#22871,#22872) -enclosing_stmt(#22871,#22825) -expr_containers(#22871,#22805) -#22873=* -typeexprs(#22873,0,#22871,-1,"Promise") -hasLocation(#22873,#21550) -enclosing_stmt(#22873,#22825) -expr_containers(#22873,#22805) -literals("Promise","Promise",#22873) +typeexprs(#22869,0,#22867,0,"T") +hasLocation(#22869,#21546) +enclosing_stmt(#22869,#22826) +expr_containers(#22869,#22805) +literals("T","T",#22869) +typebind(#22869,#22830) +#22870=* +scopes(#22870,16) +scopenodes(#22867,#22870) +scopenesting(#22870,#22829) +#22871=@"local_type_name;{U};{#22870}" +local_type_names(#22871,"U",#22870) +#22872=* +typeexprs(#22872,14,#22867,1,"Promise") +#22873=@"loc,{#10000},76,15,76,30" +locations_default(#22873,#10000,76,15,76,30) +hasLocation(#22872,#22873) +enclosing_stmt(#22872,#22826) +expr_containers(#22872,#22805) #22874=* -typeexprs(#22874,29,#22871,0,"infer U") -#22875=@"loc,{#10000},76,23,76,29" -locations_default(#22875,#10000,76,23,76,29) -hasLocation(#22874,#22875) -enclosing_stmt(#22874,#22825) +typeexprs(#22874,0,#22872,-1,"Promise") +hasLocation(#22874,#21550) +enclosing_stmt(#22874,#22826) expr_containers(#22874,#22805) -#22876=* -typeexprs(#22876,22,#22874,0,"U") -hasLocation(#22876,#21556) -enclosing_stmt(#22876,#22825) -expr_containers(#22876,#22805) +literals("Promise","Promise",#22874) +#22875=* +typeexprs(#22875,29,#22872,0,"infer U") +#22876=@"loc,{#10000},76,23,76,29" +locations_default(#22876,#10000,76,23,76,29) +hasLocation(#22875,#22876) +enclosing_stmt(#22875,#22826) +expr_containers(#22875,#22805) #22877=* -typeexprs(#22877,1,#22876,0,"U") +typeexprs(#22877,22,#22875,0,"U") hasLocation(#22877,#21556) -enclosing_stmt(#22877,#22825) +enclosing_stmt(#22877,#22826) expr_containers(#22877,#22805) -literals("U","U",#22877) -typedecl(#22877,#22870) #22878=* -typeexprs(#22878,0,#22866,2,"U") -hasLocation(#22878,#21562) -enclosing_stmt(#22878,#22825) +typeexprs(#22878,1,#22877,0,"U") +hasLocation(#22878,#21556) +enclosing_stmt(#22878,#22826) expr_containers(#22878,#22805) literals("U","U",#22878) -typebind(#22878,#22870) +typedecl(#22878,#22871) #22879=* -typeexprs(#22879,0,#22866,3,"T") -hasLocation(#22879,#21566) -enclosing_stmt(#22879,#22825) +typeexprs(#22879,0,#22867,2,"U") +hasLocation(#22879,#21562) +enclosing_stmt(#22879,#22826) expr_containers(#22879,#22805) -literals("T","T",#22879) -typebind(#22879,#22829) +literals("U","U",#22879) +typebind(#22879,#22871) #22880=* -stmts(#22880,35,#22805,1,"type T0 ... tring>;") -#22881=@"loc,{#10000},79,3,79,29" -locations_default(#22881,#10000,79,3,79,29) -hasLocation(#22880,#22881) -stmt_containers(#22880,#22805) -#22882=* -typeexprs(#22882,1,#22880,0,"T0") -hasLocation(#22882,#21572) -enclosing_stmt(#22882,#22880) -expr_containers(#22882,#22805) -literals("T0","T0",#22882) -typedecl(#22882,#22810) +typeexprs(#22880,0,#22867,3,"T") +hasLocation(#22880,#21566) +enclosing_stmt(#22880,#22826) +expr_containers(#22880,#22805) +literals("T","T",#22880) +typebind(#22880,#22830) +#22881=* +stmts(#22881,35,#22805,1,"type T0 ... tring>;") +#22882=@"loc,{#10000},79,3,79,29" +locations_default(#22882,#10000,79,3,79,29) +hasLocation(#22881,#22882) +stmt_containers(#22881,#22805) #22883=* -typeexprs(#22883,14,#22880,1,"Unpacked") -#22884=@"loc,{#10000},79,13,79,28" -locations_default(#22884,#10000,79,13,79,28) -hasLocation(#22883,#22884) -enclosing_stmt(#22883,#22880) +typeexprs(#22883,1,#22881,0,"T0") +hasLocation(#22883,#21572) +enclosing_stmt(#22883,#22881) expr_containers(#22883,#22805) -#22885=* -typeexprs(#22885,0,#22883,-1,"Unpacked") -hasLocation(#22885,#21576) -enclosing_stmt(#22885,#22880) -expr_containers(#22885,#22805) -literals("Unpacked","Unpacked",#22885) -typebind(#22885,#22809) +literals("T0","T0",#22883) +typedecl(#22883,#22811) +#22884=* +typeexprs(#22884,14,#22881,1,"Unpacked") +#22885=@"loc,{#10000},79,13,79,28" +locations_default(#22885,#10000,79,13,79,28) +hasLocation(#22884,#22885) +enclosing_stmt(#22884,#22881) +expr_containers(#22884,#22805) #22886=* -typeexprs(#22886,2,#22883,0,"string") -hasLocation(#22886,#21580) -enclosing_stmt(#22886,#22880) +typeexprs(#22886,0,#22884,-1,"Unpacked") +hasLocation(#22886,#21576) +enclosing_stmt(#22886,#22881) expr_containers(#22886,#22805) -literals("string","string",#22886) +literals("Unpacked","Unpacked",#22886) +typebind(#22886,#22810) #22887=* -stmts(#22887,35,#22805,2,"type T1 ... ing[]>;") -#22888=@"loc,{#10000},80,3,80,31" -locations_default(#22888,#10000,80,3,80,31) -hasLocation(#22887,#22888) -stmt_containers(#22887,#22805) -#22889=* -typeexprs(#22889,1,#22887,0,"T1") -hasLocation(#22889,#21588) -enclosing_stmt(#22889,#22887) -expr_containers(#22889,#22805) -literals("T1","T1",#22889) -typedecl(#22889,#22811) +typeexprs(#22887,2,#22884,0,"string") +hasLocation(#22887,#21580) +enclosing_stmt(#22887,#22881) +expr_containers(#22887,#22805) +literals("string","string",#22887) +#22888=* +stmts(#22888,35,#22805,2,"type T1 ... ing[]>;") +#22889=@"loc,{#10000},80,3,80,31" +locations_default(#22889,#10000,80,3,80,31) +hasLocation(#22888,#22889) +stmt_containers(#22888,#22805) #22890=* -typeexprs(#22890,14,#22887,1,"Unpacked") -#22891=@"loc,{#10000},80,13,80,30" -locations_default(#22891,#10000,80,13,80,30) -hasLocation(#22890,#22891) -enclosing_stmt(#22890,#22887) +typeexprs(#22890,1,#22888,0,"T1") +hasLocation(#22890,#21588) +enclosing_stmt(#22890,#22888) expr_containers(#22890,#22805) -#22892=* -typeexprs(#22892,0,#22890,-1,"Unpacked") -hasLocation(#22892,#21592) -enclosing_stmt(#22892,#22887) -expr_containers(#22892,#22805) -literals("Unpacked","Unpacked",#22892) -typebind(#22892,#22809) +literals("T1","T1",#22890) +typedecl(#22890,#22812) +#22891=* +typeexprs(#22891,14,#22888,1,"Unpacked") +#22892=@"loc,{#10000},80,13,80,30" +locations_default(#22892,#10000,80,13,80,30) +hasLocation(#22891,#22892) +enclosing_stmt(#22891,#22888) +expr_containers(#22891,#22805) #22893=* -typeexprs(#22893,6,#22890,0,"string[]") -#22894=@"loc,{#10000},80,22,80,29" -locations_default(#22894,#10000,80,22,80,29) -hasLocation(#22893,#22894) -enclosing_stmt(#22893,#22887) +typeexprs(#22893,0,#22891,-1,"Unpacked") +hasLocation(#22893,#21592) +enclosing_stmt(#22893,#22888) expr_containers(#22893,#22805) -#22895=* -typeexprs(#22895,2,#22893,0,"string") -hasLocation(#22895,#21596) -enclosing_stmt(#22895,#22887) -expr_containers(#22895,#22805) -literals("string","string",#22895) +literals("Unpacked","Unpacked",#22893) +typebind(#22893,#22810) +#22894=* +typeexprs(#22894,6,#22891,0,"string[]") +#22895=@"loc,{#10000},80,22,80,29" +locations_default(#22895,#10000,80,22,80,29) +hasLocation(#22894,#22895) +enclosing_stmt(#22894,#22888) +expr_containers(#22894,#22805) #22896=* -stmts(#22896,35,#22805,3,"type T2 ... tring>;") -#22897=@"loc,{#10000},81,3,81,35" -locations_default(#22897,#10000,81,3,81,35) -hasLocation(#22896,#22897) -stmt_containers(#22896,#22805) -#22898=* -typeexprs(#22898,1,#22896,0,"T2") -hasLocation(#22898,#21608) -enclosing_stmt(#22898,#22896) -expr_containers(#22898,#22805) -literals("T2","T2",#22898) -typedecl(#22898,#22812) +typeexprs(#22896,2,#22894,0,"string") +hasLocation(#22896,#21596) +enclosing_stmt(#22896,#22888) +expr_containers(#22896,#22805) +literals("string","string",#22896) +#22897=* +stmts(#22897,35,#22805,3,"type T2 ... tring>;") +#22898=@"loc,{#10000},81,3,81,35" +locations_default(#22898,#10000,81,3,81,35) +hasLocation(#22897,#22898) +stmt_containers(#22897,#22805) #22899=* -typeexprs(#22899,14,#22896,1,"Unpacke ... string>") -#22900=@"loc,{#10000},81,13,81,34" -locations_default(#22900,#10000,81,13,81,34) -hasLocation(#22899,#22900) -enclosing_stmt(#22899,#22896) +typeexprs(#22899,1,#22897,0,"T2") +hasLocation(#22899,#21608) +enclosing_stmt(#22899,#22897) expr_containers(#22899,#22805) -#22901=* -typeexprs(#22901,0,#22899,-1,"Unpacked") -hasLocation(#22901,#21612) -enclosing_stmt(#22901,#22896) -expr_containers(#22901,#22805) -literals("Unpacked","Unpacked",#22901) -typebind(#22901,#22809) +literals("T2","T2",#22899) +typedecl(#22899,#22813) +#22900=* +typeexprs(#22900,14,#22897,1,"Unpacke ... string>") +#22901=@"loc,{#10000},81,13,81,34" +locations_default(#22901,#10000,81,13,81,34) +hasLocation(#22900,#22901) +enclosing_stmt(#22900,#22897) +expr_containers(#22900,#22805) #22902=* -typeexprs(#22902,23,#22899,0,"() => string") -#22903=@"loc,{#10000},81,22,81,33" -locations_default(#22903,#10000,81,22,81,33) -hasLocation(#22902,#22903) -enclosing_stmt(#22902,#22896) +typeexprs(#22902,0,#22900,-1,"Unpacked") +hasLocation(#22902,#21612) +enclosing_stmt(#22902,#22897) expr_containers(#22902,#22805) -#22904=* -exprs(#22904,9,#22902,0,"() => string") -hasLocation(#22904,#22903) -enclosing_stmt(#22904,#22896) -expr_containers(#22904,#22805) +literals("Unpacked","Unpacked",#22902) +typebind(#22902,#22810) +#22903=* +typeexprs(#22903,23,#22900,0,"() => string") +#22904=@"loc,{#10000},81,22,81,33" +locations_default(#22904,#10000,81,22,81,33) +hasLocation(#22903,#22904) +enclosing_stmt(#22903,#22897) +expr_containers(#22903,#22805) #22905=* -scopes(#22905,1) -scopenodes(#22904,#22905) -scopenesting(#22905,#22808) -#22906=@"var;{arguments};{#22905}" -variables(#22906,"arguments",#22905) -is_arguments_object(#22906) -#22907=* -typeexprs(#22907,2,#22904,-3,"string") -hasLocation(#22907,#21622) -expr_containers(#22907,#22904) -literals("string","string",#22907) +exprs(#22905,9,#22903,0,"() => string") +hasLocation(#22905,#22904) +enclosing_stmt(#22905,#22897) +expr_containers(#22905,#22805) +#22906=* +scopes(#22906,1) +scopenodes(#22905,#22906) +scopenesting(#22906,#22808) +#22907=@"var;{arguments};{#22906}" +variables(#22907,"arguments",#22906) +is_arguments_object(#22907) #22908=* -stmts(#22908,35,#22805,4,"type T3 ... ring>>;") -#22909=@"loc,{#10000},82,3,82,38" -locations_default(#22909,#10000,82,3,82,38) -hasLocation(#22908,#22909) -stmt_containers(#22908,#22805) -#22910=* -typeexprs(#22910,1,#22908,0,"T3") -hasLocation(#22910,#21630) -enclosing_stmt(#22910,#22908) -expr_containers(#22910,#22805) -literals("T3","T3",#22910) -typedecl(#22910,#22813) +typeexprs(#22908,2,#22905,-3,"string") +hasLocation(#22908,#21622) +expr_containers(#22908,#22905) +literals("string","string",#22908) +#22909=* +stmts(#22909,35,#22805,4,"type T3 ... ring>>;") +#22910=@"loc,{#10000},82,3,82,38" +locations_default(#22910,#10000,82,3,82,38) +hasLocation(#22909,#22910) +stmt_containers(#22909,#22805) #22911=* -typeexprs(#22911,14,#22908,1,"Unpacke ... tring>>") -#22912=@"loc,{#10000},82,13,82,37" -locations_default(#22912,#10000,82,13,82,37) -hasLocation(#22911,#22912) -enclosing_stmt(#22911,#22908) +typeexprs(#22911,1,#22909,0,"T3") +hasLocation(#22911,#21630) +enclosing_stmt(#22911,#22909) expr_containers(#22911,#22805) -#22913=* -typeexprs(#22913,0,#22911,-1,"Unpacked") -hasLocation(#22913,#21634) -enclosing_stmt(#22913,#22908) -expr_containers(#22913,#22805) -literals("Unpacked","Unpacked",#22913) -typebind(#22913,#22809) +literals("T3","T3",#22911) +typedecl(#22911,#22814) +#22912=* +typeexprs(#22912,14,#22909,1,"Unpacke ... tring>>") +#22913=@"loc,{#10000},82,13,82,37" +locations_default(#22913,#10000,82,13,82,37) +hasLocation(#22912,#22913) +enclosing_stmt(#22912,#22909) +expr_containers(#22912,#22805) #22914=* -typeexprs(#22914,14,#22911,0,"Promise") -#22915=@"loc,{#10000},82,22,82,36" -locations_default(#22915,#10000,82,22,82,36) -hasLocation(#22914,#22915) -enclosing_stmt(#22914,#22908) +typeexprs(#22914,0,#22912,-1,"Unpacked") +hasLocation(#22914,#21634) +enclosing_stmt(#22914,#22909) expr_containers(#22914,#22805) -#22916=* -typeexprs(#22916,0,#22914,-1,"Promise") -hasLocation(#22916,#21638) -enclosing_stmt(#22916,#22908) -expr_containers(#22916,#22805) -literals("Promise","Promise",#22916) +literals("Unpacked","Unpacked",#22914) +typebind(#22914,#22810) +#22915=* +typeexprs(#22915,14,#22912,0,"Promise") +#22916=@"loc,{#10000},82,22,82,36" +locations_default(#22916,#10000,82,22,82,36) +hasLocation(#22915,#22916) +enclosing_stmt(#22915,#22909) +expr_containers(#22915,#22805) #22917=* -typeexprs(#22917,2,#22914,0,"string") -hasLocation(#22917,#21642) -enclosing_stmt(#22917,#22908) +typeexprs(#22917,0,#22915,-1,"Promise") +hasLocation(#22917,#21638) +enclosing_stmt(#22917,#22909) expr_containers(#22917,#22805) -literals("string","string",#22917) +literals("Promise","Promise",#22917) #22918=* -stmts(#22918,35,#22805,5,"type T4 ... ng>[]>;") -#22919=@"loc,{#10000},83,3,83,40" -locations_default(#22919,#10000,83,3,83,40) -hasLocation(#22918,#22919) -stmt_containers(#22918,#22805) -#22920=* -typeexprs(#22920,1,#22918,0,"T4") -hasLocation(#22920,#21652) -enclosing_stmt(#22920,#22918) -expr_containers(#22920,#22805) -literals("T4","T4",#22920) -typedecl(#22920,#22814) +typeexprs(#22918,2,#22915,0,"string") +hasLocation(#22918,#21642) +enclosing_stmt(#22918,#22909) +expr_containers(#22918,#22805) +literals("string","string",#22918) +#22919=* +stmts(#22919,35,#22805,5,"type T4 ... ng>[]>;") +#22920=@"loc,{#10000},83,3,83,40" +locations_default(#22920,#10000,83,3,83,40) +hasLocation(#22919,#22920) +stmt_containers(#22919,#22805) #22921=* -typeexprs(#22921,14,#22918,1,"Unpacke ... ing>[]>") -#22922=@"loc,{#10000},83,13,83,39" -locations_default(#22922,#10000,83,13,83,39) -hasLocation(#22921,#22922) -enclosing_stmt(#22921,#22918) +typeexprs(#22921,1,#22919,0,"T4") +hasLocation(#22921,#21652) +enclosing_stmt(#22921,#22919) expr_containers(#22921,#22805) -#22923=* -typeexprs(#22923,0,#22921,-1,"Unpacked") -hasLocation(#22923,#21656) -enclosing_stmt(#22923,#22918) -expr_containers(#22923,#22805) -literals("Unpacked","Unpacked",#22923) -typebind(#22923,#22809) +literals("T4","T4",#22921) +typedecl(#22921,#22815) +#22922=* +typeexprs(#22922,14,#22919,1,"Unpacke ... ing>[]>") +#22923=@"loc,{#10000},83,13,83,39" +locations_default(#22923,#10000,83,13,83,39) +hasLocation(#22922,#22923) +enclosing_stmt(#22922,#22919) +expr_containers(#22922,#22805) #22924=* -typeexprs(#22924,6,#22921,0,"Promise[]") -#22925=@"loc,{#10000},83,22,83,38" -locations_default(#22925,#10000,83,22,83,38) -hasLocation(#22924,#22925) -enclosing_stmt(#22924,#22918) +typeexprs(#22924,0,#22922,-1,"Unpacked") +hasLocation(#22924,#21656) +enclosing_stmt(#22924,#22919) expr_containers(#22924,#22805) -#22926=* -typeexprs(#22926,14,#22924,0,"Promise") -#22927=@"loc,{#10000},83,22,83,36" -locations_default(#22927,#10000,83,22,83,36) -hasLocation(#22926,#22927) -enclosing_stmt(#22926,#22918) -expr_containers(#22926,#22805) -#22928=* -typeexprs(#22928,0,#22926,-1,"Promise") -hasLocation(#22928,#21660) -enclosing_stmt(#22928,#22918) -expr_containers(#22928,#22805) -literals("Promise","Promise",#22928) +literals("Unpacked","Unpacked",#22924) +typebind(#22924,#22810) +#22925=* +typeexprs(#22925,6,#22922,0,"Promise[]") +#22926=@"loc,{#10000},83,22,83,38" +locations_default(#22926,#10000,83,22,83,38) +hasLocation(#22925,#22926) +enclosing_stmt(#22925,#22919) +expr_containers(#22925,#22805) +#22927=* +typeexprs(#22927,14,#22925,0,"Promise") +#22928=@"loc,{#10000},83,22,83,36" +locations_default(#22928,#10000,83,22,83,36) +hasLocation(#22927,#22928) +enclosing_stmt(#22927,#22919) +expr_containers(#22927,#22805) #22929=* -typeexprs(#22929,2,#22926,0,"string") -hasLocation(#22929,#21664) -enclosing_stmt(#22929,#22918) +typeexprs(#22929,0,#22927,-1,"Promise") +hasLocation(#22929,#21660) +enclosing_stmt(#22929,#22919) expr_containers(#22929,#22805) -literals("string","string",#22929) +literals("Promise","Promise",#22929) #22930=* -stmts(#22930,35,#22805,6,"type T5 ... g>[]>>;") -#22931=@"loc,{#10000},84,3,84,50" -locations_default(#22931,#10000,84,3,84,50) -hasLocation(#22930,#22931) -stmt_containers(#22930,#22805) -#22932=* -typeexprs(#22932,1,#22930,0,"T5") -hasLocation(#22932,#21678) -enclosing_stmt(#22932,#22930) -expr_containers(#22932,#22805) -literals("T5","T5",#22932) -typedecl(#22932,#22815) +typeexprs(#22930,2,#22927,0,"string") +hasLocation(#22930,#21664) +enclosing_stmt(#22930,#22919) +expr_containers(#22930,#22805) +literals("string","string",#22930) +#22931=* +stmts(#22931,35,#22805,6,"type T5 ... g>[]>>;") +#22932=@"loc,{#10000},84,3,84,50" +locations_default(#22932,#10000,84,3,84,50) +hasLocation(#22931,#22932) +stmt_containers(#22931,#22805) #22933=* -typeexprs(#22933,14,#22930,1,"Unpacke ... ng>[]>>") -#22934=@"loc,{#10000},84,13,84,49" -locations_default(#22934,#10000,84,13,84,49) -hasLocation(#22933,#22934) -enclosing_stmt(#22933,#22930) +typeexprs(#22933,1,#22931,0,"T5") +hasLocation(#22933,#21678) +enclosing_stmt(#22933,#22931) expr_containers(#22933,#22805) -#22935=* -typeexprs(#22935,0,#22933,-1,"Unpacked") -hasLocation(#22935,#21682) -enclosing_stmt(#22935,#22930) -expr_containers(#22935,#22805) -literals("Unpacked","Unpacked",#22935) -typebind(#22935,#22809) +literals("T5","T5",#22933) +typedecl(#22933,#22816) +#22934=* +typeexprs(#22934,14,#22931,1,"Unpacke ... ng>[]>>") +#22935=@"loc,{#10000},84,13,84,49" +locations_default(#22935,#10000,84,13,84,49) +hasLocation(#22934,#22935) +enclosing_stmt(#22934,#22931) +expr_containers(#22934,#22805) #22936=* -typeexprs(#22936,14,#22933,0,"Unpacke ... ing>[]>") -#22937=@"loc,{#10000},84,22,84,48" -locations_default(#22937,#10000,84,22,84,48) -hasLocation(#22936,#22937) -enclosing_stmt(#22936,#22930) +typeexprs(#22936,0,#22934,-1,"Unpacked") +hasLocation(#22936,#21682) +enclosing_stmt(#22936,#22931) expr_containers(#22936,#22805) -#22938=* -typeexprs(#22938,0,#22936,-1,"Unpacked") -hasLocation(#22938,#21686) -enclosing_stmt(#22938,#22930) -expr_containers(#22938,#22805) -literals("Unpacked","Unpacked",#22938) -typebind(#22938,#22809) +literals("Unpacked","Unpacked",#22936) +typebind(#22936,#22810) +#22937=* +typeexprs(#22937,14,#22934,0,"Unpacke ... ing>[]>") +#22938=@"loc,{#10000},84,22,84,48" +locations_default(#22938,#10000,84,22,84,48) +hasLocation(#22937,#22938) +enclosing_stmt(#22937,#22931) +expr_containers(#22937,#22805) #22939=* -typeexprs(#22939,6,#22936,0,"Promise[]") -#22940=@"loc,{#10000},84,31,84,47" -locations_default(#22940,#10000,84,31,84,47) -hasLocation(#22939,#22940) -enclosing_stmt(#22939,#22930) +typeexprs(#22939,0,#22937,-1,"Unpacked") +hasLocation(#22939,#21686) +enclosing_stmt(#22939,#22931) expr_containers(#22939,#22805) -#22941=* -typeexprs(#22941,14,#22939,0,"Promise") -#22942=@"loc,{#10000},84,31,84,45" -locations_default(#22942,#10000,84,31,84,45) -hasLocation(#22941,#22942) -enclosing_stmt(#22941,#22930) -expr_containers(#22941,#22805) -#22943=* -typeexprs(#22943,0,#22941,-1,"Promise") -hasLocation(#22943,#21690) -enclosing_stmt(#22943,#22930) -expr_containers(#22943,#22805) -literals("Promise","Promise",#22943) +literals("Unpacked","Unpacked",#22939) +typebind(#22939,#22810) +#22940=* +typeexprs(#22940,6,#22937,0,"Promise[]") +#22941=@"loc,{#10000},84,31,84,47" +locations_default(#22941,#10000,84,31,84,47) +hasLocation(#22940,#22941) +enclosing_stmt(#22940,#22931) +expr_containers(#22940,#22805) +#22942=* +typeexprs(#22942,14,#22940,0,"Promise") +#22943=@"loc,{#10000},84,31,84,45" +locations_default(#22943,#10000,84,31,84,45) +hasLocation(#22942,#22943) +enclosing_stmt(#22942,#22931) +expr_containers(#22942,#22805) #22944=* -typeexprs(#22944,2,#22941,0,"string") -hasLocation(#22944,#21694) -enclosing_stmt(#22944,#22930) +typeexprs(#22944,0,#22942,-1,"Promise") +hasLocation(#22944,#21690) +enclosing_stmt(#22944,#22931) expr_containers(#22944,#22805) -literals("string","string",#22944) +literals("Promise","Promise",#22944) #22945=* -stmts(#22945,35,#22805,7,"type Fo ... never;") -#22946=@"loc,{#10000},86,3,86,65" -locations_default(#22946,#10000,86,3,86,65) -hasLocation(#22945,#22946) -stmt_containers(#22945,#22805) -#22947=* -typeexprs(#22947,1,#22945,0,"Foo") -hasLocation(#22947,#21710) -enclosing_stmt(#22947,#22945) -expr_containers(#22947,#22805) -literals("Foo","Foo",#22947) -typedecl(#22947,#22816) +typeexprs(#22945,2,#22942,0,"string") +hasLocation(#22945,#21694) +enclosing_stmt(#22945,#22931) +expr_containers(#22945,#22805) +literals("string","string",#22945) +#22946=* +stmts(#22946,35,#22805,7,"type Fo ... never;") +#22947=@"loc,{#10000},86,3,86,65" +locations_default(#22947,#10000,86,3,86,65) +hasLocation(#22946,#22947) +stmt_containers(#22946,#22805) #22948=* -scopes(#22948,12) -scopenodes(#22945,#22948) -scopenesting(#22948,#22808) -#22949=@"local_type_name;{T};{#22948}" -local_type_names(#22949,"T",#22948) -#22950=* -typeexprs(#22950,22,#22945,2,"T") -hasLocation(#22950,#21714) -enclosing_stmt(#22950,#22945) -expr_containers(#22950,#22805) +typeexprs(#22948,1,#22946,0,"Foo") +hasLocation(#22948,#21710) +enclosing_stmt(#22948,#22946) +expr_containers(#22948,#22805) +literals("Foo","Foo",#22948) +typedecl(#22948,#22817) +#22949=* +scopes(#22949,12) +scopenodes(#22946,#22949) +scopenesting(#22949,#22808) +#22950=@"local_type_name;{T};{#22949}" +local_type_names(#22950,"T",#22949) #22951=* -typeexprs(#22951,1,#22950,0,"T") +typeexprs(#22951,22,#22946,2,"T") hasLocation(#22951,#21714) -enclosing_stmt(#22951,#22945) +enclosing_stmt(#22951,#22946) expr_containers(#22951,#22805) -literals("T","T",#22951) -typedecl(#22951,#22949) #22952=* -typeexprs(#22952,28,#22945,1,"T exten ... : never") -#22953=@"loc,{#10000},86,17,86,64" -locations_default(#22953,#10000,86,17,86,64) -hasLocation(#22952,#22953) -enclosing_stmt(#22952,#22945) +typeexprs(#22952,1,#22951,0,"T") +hasLocation(#22952,#21714) +enclosing_stmt(#22952,#22946) expr_containers(#22952,#22805) -#22954=* -typeexprs(#22954,0,#22952,0,"T") -hasLocation(#22954,#21720) -enclosing_stmt(#22954,#22945) -expr_containers(#22954,#22805) -literals("T","T",#22954) -typebind(#22954,#22949) +literals("T","T",#22952) +typedecl(#22952,#22950) +#22953=* +typeexprs(#22953,28,#22946,1,"T exten ... : never") +#22954=@"loc,{#10000},86,17,86,64" +locations_default(#22954,#10000,86,17,86,64) +hasLocation(#22953,#22954) +enclosing_stmt(#22953,#22946) +expr_containers(#22953,#22805) #22955=* -typeexprs(#22955,21,#22952,1,"{ a: in ... fer U }") -#22956=@"loc,{#10000},86,27,86,52" -locations_default(#22956,#10000,86,27,86,52) -hasLocation(#22955,#22956) -enclosing_stmt(#22955,#22945) +typeexprs(#22955,0,#22953,0,"T") +hasLocation(#22955,#21720) +enclosing_stmt(#22955,#22946) expr_containers(#22955,#22805) -#22957=* -properties(#22957,#22955,0,8,"a: infer U,") -#22958=@"loc,{#10000},86,29,86,39" -locations_default(#22958,#10000,86,29,86,39) -hasLocation(#22957,#22958) -#22959=* -exprs(#22959,0,#22957,0,"a") -hasLocation(#22959,#21726) -enclosing_stmt(#22959,#22945) -expr_containers(#22959,#22805) -literals("a","a",#22959) -is_abstract_member(#22957) +literals("T","T",#22955) +typebind(#22955,#22950) +#22956=* +typeexprs(#22956,21,#22953,1,"{ a: in ... fer U }") +#22957=@"loc,{#10000},86,27,86,52" +locations_default(#22957,#10000,86,27,86,52) +hasLocation(#22956,#22957) +enclosing_stmt(#22956,#22946) +expr_containers(#22956,#22805) +#22958=* +properties(#22958,#22956,0,8,"a: infer U,") +#22959=@"loc,{#10000},86,29,86,39" +locations_default(#22959,#10000,86,29,86,39) +hasLocation(#22958,#22959) #22960=* -typeexprs(#22960,29,#22957,2,"infer U") -#22961=@"loc,{#10000},86,32,86,38" -locations_default(#22961,#10000,86,32,86,38) -hasLocation(#22960,#22961) -enclosing_stmt(#22960,#22945) +exprs(#22960,0,#22958,0,"a") +hasLocation(#22960,#21726) +enclosing_stmt(#22960,#22946) expr_containers(#22960,#22805) -#22962=* -typeexprs(#22962,22,#22960,0,"U") -hasLocation(#22962,#21732) -enclosing_stmt(#22962,#22945) -expr_containers(#22962,#22805) +literals("a","a",#22960) +is_abstract_member(#22958) +#22961=* +typeexprs(#22961,29,#22958,2,"infer U") +#22962=@"loc,{#10000},86,32,86,38" +locations_default(#22962,#10000,86,32,86,38) +hasLocation(#22961,#22962) +enclosing_stmt(#22961,#22946) +expr_containers(#22961,#22805) #22963=* -typeexprs(#22963,1,#22962,0,"U") +typeexprs(#22963,22,#22961,0,"U") hasLocation(#22963,#21732) -enclosing_stmt(#22963,#22945) +enclosing_stmt(#22963,#22946) expr_containers(#22963,#22805) -literals("U","U",#22963) #22964=* -properties(#22964,#22955,1,8,"b: infer U") -#22965=@"loc,{#10000},86,41,86,50" -locations_default(#22965,#10000,86,41,86,50) -hasLocation(#22964,#22965) -#22966=* -exprs(#22966,0,#22964,0,"b") -hasLocation(#22966,#21736) -enclosing_stmt(#22966,#22945) -expr_containers(#22966,#22805) -literals("b","b",#22966) -is_abstract_member(#22964) +typeexprs(#22964,1,#22963,0,"U") +hasLocation(#22964,#21732) +enclosing_stmt(#22964,#22946) +expr_containers(#22964,#22805) +literals("U","U",#22964) +#22965=* +properties(#22965,#22956,1,8,"b: infer U") +#22966=@"loc,{#10000},86,41,86,50" +locations_default(#22966,#10000,86,41,86,50) +hasLocation(#22965,#22966) #22967=* -typeexprs(#22967,29,#22964,2,"infer U") -#22968=@"loc,{#10000},86,44,86,50" -locations_default(#22968,#10000,86,44,86,50) -hasLocation(#22967,#22968) -enclosing_stmt(#22967,#22945) +exprs(#22967,0,#22965,0,"b") +hasLocation(#22967,#21736) +enclosing_stmt(#22967,#22946) expr_containers(#22967,#22805) -#22969=* -typeexprs(#22969,22,#22967,0,"U") -hasLocation(#22969,#21742) -enclosing_stmt(#22969,#22945) -expr_containers(#22969,#22805) +literals("b","b",#22967) +is_abstract_member(#22965) +#22968=* +typeexprs(#22968,29,#22965,2,"infer U") +#22969=@"loc,{#10000},86,44,86,50" +locations_default(#22969,#10000,86,44,86,50) +hasLocation(#22968,#22969) +enclosing_stmt(#22968,#22946) +expr_containers(#22968,#22805) #22970=* -typeexprs(#22970,1,#22969,0,"U") +typeexprs(#22970,22,#22968,0,"U") hasLocation(#22970,#21742) -enclosing_stmt(#22970,#22945) +enclosing_stmt(#22970,#22946) expr_containers(#22970,#22805) -literals("U","U",#22970) #22971=* -typeexprs(#22971,0,#22952,2,"U") -hasLocation(#22971,#21748) -enclosing_stmt(#22971,#22945) +typeexprs(#22971,1,#22970,0,"U") +hasLocation(#22971,#21742) +enclosing_stmt(#22971,#22946) expr_containers(#22971,#22805) literals("U","U",#22971) #22972=* -typeexprs(#22972,2,#22952,3,"never") -hasLocation(#22972,#21752) -enclosing_stmt(#22972,#22945) +typeexprs(#22972,0,#22953,2,"U") +hasLocation(#22972,#21748) +enclosing_stmt(#22972,#22946) expr_containers(#22972,#22805) -literals("never","never",#22972) +literals("U","U",#22972) #22973=* -stmts(#22973,35,#22805,8,"type T1 ... ing }>;") -#22974=@"loc,{#10000},87,3,87,43" -locations_default(#22974,#10000,87,3,87,43) -hasLocation(#22973,#22974) -stmt_containers(#22973,#22805) -#22975=* -typeexprs(#22975,1,#22973,0,"T10") -hasLocation(#22975,#21758) -enclosing_stmt(#22975,#22973) -expr_containers(#22975,#22805) -literals("T10","T10",#22975) -typedecl(#22975,#22817) +typeexprs(#22973,2,#22953,3,"never") +hasLocation(#22973,#21752) +enclosing_stmt(#22973,#22946) +expr_containers(#22973,#22805) +literals("never","never",#22973) +#22974=* +stmts(#22974,35,#22805,8,"type T1 ... ing }>;") +#22975=@"loc,{#10000},87,3,87,43" +locations_default(#22975,#10000,87,3,87,43) +hasLocation(#22974,#22975) +stmt_containers(#22974,#22805) #22976=* -typeexprs(#22976,14,#22973,1,"Foo<{ a ... ring }>") -#22977=@"loc,{#10000},87,14,87,42" -locations_default(#22977,#10000,87,14,87,42) -hasLocation(#22976,#22977) -enclosing_stmt(#22976,#22973) +typeexprs(#22976,1,#22974,0,"T10") +hasLocation(#22976,#21758) +enclosing_stmt(#22976,#22974) expr_containers(#22976,#22805) -#22978=* -typeexprs(#22978,0,#22976,-1,"Foo") -hasLocation(#22978,#21762) -enclosing_stmt(#22978,#22973) -expr_containers(#22978,#22805) -literals("Foo","Foo",#22978) -typebind(#22978,#22816) +literals("T10","T10",#22976) +typedecl(#22976,#22818) +#22977=* +typeexprs(#22977,14,#22974,1,"Foo<{ a ... ring }>") +#22978=@"loc,{#10000},87,14,87,42" +locations_default(#22978,#10000,87,14,87,42) +hasLocation(#22977,#22978) +enclosing_stmt(#22977,#22974) +expr_containers(#22977,#22805) #22979=* -typeexprs(#22979,21,#22976,0,"{ a: st ... tring }") -#22980=@"loc,{#10000},87,18,87,41" -locations_default(#22980,#10000,87,18,87,41) -hasLocation(#22979,#22980) -enclosing_stmt(#22979,#22973) +typeexprs(#22979,0,#22977,-1,"Foo") +hasLocation(#22979,#21762) +enclosing_stmt(#22979,#22974) expr_containers(#22979,#22805) -#22981=* -properties(#22981,#22979,0,8,"a: string,") -#22982=@"loc,{#10000},87,20,87,29" -locations_default(#22982,#10000,87,20,87,29) -hasLocation(#22981,#22982) -#22983=* -exprs(#22983,0,#22981,0,"a") -hasLocation(#22983,#21768) -enclosing_stmt(#22983,#22973) -expr_containers(#22983,#22805) -literals("a","a",#22983) -is_abstract_member(#22981) +literals("Foo","Foo",#22979) +typebind(#22979,#22817) +#22980=* +typeexprs(#22980,21,#22977,0,"{ a: st ... tring }") +#22981=@"loc,{#10000},87,18,87,41" +locations_default(#22981,#10000,87,18,87,41) +hasLocation(#22980,#22981) +enclosing_stmt(#22980,#22974) +expr_containers(#22980,#22805) +#22982=* +properties(#22982,#22980,0,8,"a: string,") +#22983=@"loc,{#10000},87,20,87,29" +locations_default(#22983,#10000,87,20,87,29) +hasLocation(#22982,#22983) #22984=* -typeexprs(#22984,2,#22981,2,"string") -hasLocation(#22984,#21772) -enclosing_stmt(#22984,#22973) +exprs(#22984,0,#22982,0,"a") +hasLocation(#22984,#21768) +enclosing_stmt(#22984,#22974) expr_containers(#22984,#22805) -literals("string","string",#22984) +literals("a","a",#22984) +is_abstract_member(#22982) #22985=* -properties(#22985,#22979,1,8,"b: string") -#22986=@"loc,{#10000},87,31,87,39" -locations_default(#22986,#10000,87,31,87,39) -hasLocation(#22985,#22986) -#22987=* -exprs(#22987,0,#22985,0,"b") -hasLocation(#22987,#21776) -enclosing_stmt(#22987,#22973) -expr_containers(#22987,#22805) -literals("b","b",#22987) -is_abstract_member(#22985) +typeexprs(#22985,2,#22982,2,"string") +hasLocation(#22985,#21772) +enclosing_stmt(#22985,#22974) +expr_containers(#22985,#22805) +literals("string","string",#22985) +#22986=* +properties(#22986,#22980,1,8,"b: string") +#22987=@"loc,{#10000},87,31,87,39" +locations_default(#22987,#10000,87,31,87,39) +hasLocation(#22986,#22987) #22988=* -typeexprs(#22988,2,#22985,2,"string") -hasLocation(#22988,#21780) -enclosing_stmt(#22988,#22973) +exprs(#22988,0,#22986,0,"b") +hasLocation(#22988,#21776) +enclosing_stmt(#22988,#22974) expr_containers(#22988,#22805) -literals("string","string",#22988) +literals("b","b",#22988) +is_abstract_member(#22986) #22989=* -stmts(#22989,35,#22805,9,"type T1 ... ber }>;") -#22990=@"loc,{#10000},88,3,88,43" -locations_default(#22990,#10000,88,3,88,43) -hasLocation(#22989,#22990) -stmt_containers(#22989,#22805) -#22991=* -typeexprs(#22991,1,#22989,0,"T11") -hasLocation(#22991,#21790) -enclosing_stmt(#22991,#22989) -expr_containers(#22991,#22805) -literals("T11","T11",#22991) -typedecl(#22991,#22818) +typeexprs(#22989,2,#22986,2,"string") +hasLocation(#22989,#21780) +enclosing_stmt(#22989,#22974) +expr_containers(#22989,#22805) +literals("string","string",#22989) +#22990=* +stmts(#22990,35,#22805,9,"type T1 ... ber }>;") +#22991=@"loc,{#10000},88,3,88,43" +locations_default(#22991,#10000,88,3,88,43) +hasLocation(#22990,#22991) +stmt_containers(#22990,#22805) #22992=* -typeexprs(#22992,14,#22989,1,"Foo<{ a ... mber }>") -#22993=@"loc,{#10000},88,14,88,42" -locations_default(#22993,#10000,88,14,88,42) -hasLocation(#22992,#22993) -enclosing_stmt(#22992,#22989) +typeexprs(#22992,1,#22990,0,"T11") +hasLocation(#22992,#21790) +enclosing_stmt(#22992,#22990) expr_containers(#22992,#22805) -#22994=* -typeexprs(#22994,0,#22992,-1,"Foo") -hasLocation(#22994,#21794) -enclosing_stmt(#22994,#22989) -expr_containers(#22994,#22805) -literals("Foo","Foo",#22994) -typebind(#22994,#22816) +literals("T11","T11",#22992) +typedecl(#22992,#22819) +#22993=* +typeexprs(#22993,14,#22990,1,"Foo<{ a ... mber }>") +#22994=@"loc,{#10000},88,14,88,42" +locations_default(#22994,#10000,88,14,88,42) +hasLocation(#22993,#22994) +enclosing_stmt(#22993,#22990) +expr_containers(#22993,#22805) #22995=* -typeexprs(#22995,21,#22992,0,"{ a: st ... umber }") -#22996=@"loc,{#10000},88,18,88,41" -locations_default(#22996,#10000,88,18,88,41) -hasLocation(#22995,#22996) -enclosing_stmt(#22995,#22989) +typeexprs(#22995,0,#22993,-1,"Foo") +hasLocation(#22995,#21794) +enclosing_stmt(#22995,#22990) expr_containers(#22995,#22805) -#22997=* -properties(#22997,#22995,0,8,"a: string,") -#22998=@"loc,{#10000},88,20,88,29" -locations_default(#22998,#10000,88,20,88,29) -hasLocation(#22997,#22998) -#22999=* -exprs(#22999,0,#22997,0,"a") -hasLocation(#22999,#21800) -enclosing_stmt(#22999,#22989) -expr_containers(#22999,#22805) -literals("a","a",#22999) -is_abstract_member(#22997) +literals("Foo","Foo",#22995) +typebind(#22995,#22817) +#22996=* +typeexprs(#22996,21,#22993,0,"{ a: st ... umber }") +#22997=@"loc,{#10000},88,18,88,41" +locations_default(#22997,#10000,88,18,88,41) +hasLocation(#22996,#22997) +enclosing_stmt(#22996,#22990) +expr_containers(#22996,#22805) +#22998=* +properties(#22998,#22996,0,8,"a: string,") +#22999=@"loc,{#10000},88,20,88,29" +locations_default(#22999,#10000,88,20,88,29) +hasLocation(#22998,#22999) #23000=* -typeexprs(#23000,2,#22997,2,"string") -hasLocation(#23000,#21804) -enclosing_stmt(#23000,#22989) +exprs(#23000,0,#22998,0,"a") +hasLocation(#23000,#21800) +enclosing_stmt(#23000,#22990) expr_containers(#23000,#22805) -literals("string","string",#23000) +literals("a","a",#23000) +is_abstract_member(#22998) #23001=* -properties(#23001,#22995,1,8,"b: number") -#23002=@"loc,{#10000},88,31,88,39" -locations_default(#23002,#10000,88,31,88,39) -hasLocation(#23001,#23002) -#23003=* -exprs(#23003,0,#23001,0,"b") -hasLocation(#23003,#21808) -enclosing_stmt(#23003,#22989) -expr_containers(#23003,#22805) -literals("b","b",#23003) -is_abstract_member(#23001) +typeexprs(#23001,2,#22998,2,"string") +hasLocation(#23001,#21804) +enclosing_stmt(#23001,#22990) +expr_containers(#23001,#22805) +literals("string","string",#23001) +#23002=* +properties(#23002,#22996,1,8,"b: number") +#23003=@"loc,{#10000},88,31,88,39" +locations_default(#23003,#10000,88,31,88,39) +hasLocation(#23002,#23003) #23004=* -typeexprs(#23004,2,#23001,2,"number") -hasLocation(#23004,#21812) -enclosing_stmt(#23004,#22989) +exprs(#23004,0,#23002,0,"b") +hasLocation(#23004,#21808) +enclosing_stmt(#23004,#22990) expr_containers(#23004,#22805) -literals("number","number",#23004) +literals("b","b",#23004) +is_abstract_member(#23002) #23005=* -stmts(#23005,35,#22805,10,"type Ba ... never;") -#23006=@"loc,{#10000},90,3,90,91" -locations_default(#23006,#10000,90,3,90,91) -hasLocation(#23005,#23006) -stmt_containers(#23005,#22805) -#23007=* -typeexprs(#23007,1,#23005,0,"Bar") -hasLocation(#23007,#21822) -enclosing_stmt(#23007,#23005) -expr_containers(#23007,#22805) -literals("Bar","Bar",#23007) -typedecl(#23007,#22819) +typeexprs(#23005,2,#23002,2,"number") +hasLocation(#23005,#21812) +enclosing_stmt(#23005,#22990) +expr_containers(#23005,#22805) +literals("number","number",#23005) +#23006=* +stmts(#23006,35,#22805,10,"type Ba ... never;") +#23007=@"loc,{#10000},90,3,90,91" +locations_default(#23007,#10000,90,3,90,91) +hasLocation(#23006,#23007) +stmt_containers(#23006,#22805) #23008=* -scopes(#23008,12) -scopenodes(#23005,#23008) -scopenesting(#23008,#22808) -#23009=@"local_type_name;{T};{#23008}" -local_type_names(#23009,"T",#23008) -#23010=* -typeexprs(#23010,22,#23005,2,"T") -hasLocation(#23010,#21826) -enclosing_stmt(#23010,#23005) -expr_containers(#23010,#22805) +typeexprs(#23008,1,#23006,0,"Bar") +hasLocation(#23008,#21822) +enclosing_stmt(#23008,#23006) +expr_containers(#23008,#22805) +literals("Bar","Bar",#23008) +typedecl(#23008,#22820) +#23009=* +scopes(#23009,12) +scopenodes(#23006,#23009) +scopenesting(#23009,#22808) +#23010=@"local_type_name;{T};{#23009}" +local_type_names(#23010,"T",#23009) #23011=* -typeexprs(#23011,1,#23010,0,"T") +typeexprs(#23011,22,#23006,2,"T") hasLocation(#23011,#21826) -enclosing_stmt(#23011,#23005) +enclosing_stmt(#23011,#23006) expr_containers(#23011,#22805) -literals("T","T",#23011) -typedecl(#23011,#23009) #23012=* -typeexprs(#23012,28,#23005,1,"T exten ... : never") -#23013=@"loc,{#10000},90,17,90,90" -locations_default(#23013,#10000,90,17,90,90) -hasLocation(#23012,#23013) -enclosing_stmt(#23012,#23005) +typeexprs(#23012,1,#23011,0,"T") +hasLocation(#23012,#21826) +enclosing_stmt(#23012,#23006) expr_containers(#23012,#22805) -#23014=* -typeexprs(#23014,0,#23012,0,"T") -hasLocation(#23014,#21832) -enclosing_stmt(#23014,#23005) -expr_containers(#23014,#22805) -literals("T","T",#23014) -typebind(#23014,#23009) +literals("T","T",#23012) +typedecl(#23012,#23010) +#23013=* +typeexprs(#23013,28,#23006,1,"T exten ... : never") +#23014=@"loc,{#10000},90,17,90,90" +locations_default(#23014,#10000,90,17,90,90) +hasLocation(#23013,#23014) +enclosing_stmt(#23013,#23006) +expr_containers(#23013,#22805) #23015=* -typeexprs(#23015,21,#23012,1,"{ a: (x ... void }") -#23016=@"loc,{#10000},90,27,90,78" -locations_default(#23016,#10000,90,27,90,78) -hasLocation(#23015,#23016) -enclosing_stmt(#23015,#23005) +typeexprs(#23015,0,#23013,0,"T") +hasLocation(#23015,#21832) +enclosing_stmt(#23015,#23006) expr_containers(#23015,#22805) -#23017=* -properties(#23017,#23015,0,8,"a: (x: ... > void,") -#23018=@"loc,{#10000},90,29,90,52" -locations_default(#23018,#10000,90,29,90,52) -hasLocation(#23017,#23018) -#23019=* -exprs(#23019,0,#23017,0,"a") -hasLocation(#23019,#21838) -enclosing_stmt(#23019,#23005) -expr_containers(#23019,#22805) -literals("a","a",#23019) -is_abstract_member(#23017) +literals("T","T",#23015) +typebind(#23015,#23010) +#23016=* +typeexprs(#23016,21,#23013,1,"{ a: (x ... void }") +#23017=@"loc,{#10000},90,27,90,78" +locations_default(#23017,#10000,90,27,90,78) +hasLocation(#23016,#23017) +enclosing_stmt(#23016,#23006) +expr_containers(#23016,#22805) +#23018=* +properties(#23018,#23016,0,8,"a: (x: ... > void,") +#23019=@"loc,{#10000},90,29,90,52" +locations_default(#23019,#10000,90,29,90,52) +hasLocation(#23018,#23019) #23020=* -typeexprs(#23020,23,#23017,2,"(x: infer U) => void") -#23021=@"loc,{#10000},90,32,90,51" -locations_default(#23021,#10000,90,32,90,51) -hasLocation(#23020,#23021) -enclosing_stmt(#23020,#23005) +exprs(#23020,0,#23018,0,"a") +hasLocation(#23020,#21838) +enclosing_stmt(#23020,#23006) expr_containers(#23020,#22805) -#23022=* -exprs(#23022,9,#23020,0,"(x: infer U) => void") -hasLocation(#23022,#23021) -enclosing_stmt(#23022,#23005) -expr_containers(#23022,#22805) +literals("a","a",#23020) +is_abstract_member(#23018) +#23021=* +typeexprs(#23021,23,#23018,2,"(x: infer U) => void") +#23022=@"loc,{#10000},90,32,90,51" +locations_default(#23022,#10000,90,32,90,51) +hasLocation(#23021,#23022) +enclosing_stmt(#23021,#23006) +expr_containers(#23021,#22805) #23023=* -scopes(#23023,1) -scopenodes(#23022,#23023) -scopenesting(#23023,#23008) -#23024=@"var;{x};{#23023}" -variables(#23024,"x",#23023) -#23025=* -exprs(#23025,78,#23022,0,"x") -hasLocation(#23025,#21844) -expr_containers(#23025,#23022) -literals("x","x",#23025) -decl(#23025,#23024) -#23026=@"var;{arguments};{#23023}" -variables(#23026,"arguments",#23023) -is_arguments_object(#23026) -#23027=* -typeexprs(#23027,2,#23022,-3,"void") -hasLocation(#23027,#21856) -expr_containers(#23027,#23022) -literals("void","void",#23027) +exprs(#23023,9,#23021,0,"(x: infer U) => void") +hasLocation(#23023,#23022) +enclosing_stmt(#23023,#23006) +expr_containers(#23023,#22805) +#23024=* +scopes(#23024,1) +scopenodes(#23023,#23024) +scopenesting(#23024,#23009) +#23025=@"var;{x};{#23024}" +variables(#23025,"x",#23024) +#23026=* +exprs(#23026,78,#23023,0,"x") +hasLocation(#23026,#21844) +expr_containers(#23026,#23023) +literals("x","x",#23026) +decl(#23026,#23025) +#23027=@"var;{arguments};{#23024}" +variables(#23027,"arguments",#23024) +is_arguments_object(#23027) #23028=* -typeexprs(#23028,29,#23022,-6,"infer U") -#23029=@"loc,{#10000},90,36,90,42" -locations_default(#23029,#10000,90,36,90,42) -hasLocation(#23028,#23029) -expr_containers(#23028,#23022) -#23030=* -typeexprs(#23030,22,#23028,0,"U") -hasLocation(#23030,#21850) -expr_containers(#23030,#23022) +typeexprs(#23028,2,#23023,-3,"void") +hasLocation(#23028,#21856) +expr_containers(#23028,#23023) +literals("void","void",#23028) +#23029=* +typeexprs(#23029,29,#23023,-6,"infer U") +#23030=@"loc,{#10000},90,36,90,42" +locations_default(#23030,#10000,90,36,90,42) +hasLocation(#23029,#23030) +expr_containers(#23029,#23023) #23031=* -typeexprs(#23031,1,#23030,0,"U") +typeexprs(#23031,22,#23029,0,"U") hasLocation(#23031,#21850) -expr_containers(#23031,#23022) -literals("U","U",#23031) +expr_containers(#23031,#23023) #23032=* -properties(#23032,#23015,1,8,"b: (x: ... => void") -#23033=@"loc,{#10000},90,54,90,76" -locations_default(#23033,#10000,90,54,90,76) -hasLocation(#23032,#23033) -#23034=* -exprs(#23034,0,#23032,0,"b") -hasLocation(#23034,#21860) -enclosing_stmt(#23034,#23005) -expr_containers(#23034,#22805) -literals("b","b",#23034) -is_abstract_member(#23032) +typeexprs(#23032,1,#23031,0,"U") +hasLocation(#23032,#21850) +expr_containers(#23032,#23023) +literals("U","U",#23032) +#23033=* +properties(#23033,#23016,1,8,"b: (x: ... => void") +#23034=@"loc,{#10000},90,54,90,76" +locations_default(#23034,#10000,90,54,90,76) +hasLocation(#23033,#23034) #23035=* -typeexprs(#23035,23,#23032,2,"(x: infer U) => void") -#23036=@"loc,{#10000},90,57,90,76" -locations_default(#23036,#10000,90,57,90,76) -hasLocation(#23035,#23036) -enclosing_stmt(#23035,#23005) +exprs(#23035,0,#23033,0,"b") +hasLocation(#23035,#21860) +enclosing_stmt(#23035,#23006) expr_containers(#23035,#22805) -#23037=* -exprs(#23037,9,#23035,0,"(x: infer U) => void") -hasLocation(#23037,#23036) -enclosing_stmt(#23037,#23005) -expr_containers(#23037,#22805) +literals("b","b",#23035) +is_abstract_member(#23033) +#23036=* +typeexprs(#23036,23,#23033,2,"(x: infer U) => void") +#23037=@"loc,{#10000},90,57,90,76" +locations_default(#23037,#10000,90,57,90,76) +hasLocation(#23036,#23037) +enclosing_stmt(#23036,#23006) +expr_containers(#23036,#22805) #23038=* -scopes(#23038,1) -scopenodes(#23037,#23038) -scopenesting(#23038,#23008) -#23039=@"var;{x};{#23038}" -variables(#23039,"x",#23038) -#23040=* -exprs(#23040,78,#23037,0,"x") -hasLocation(#23040,#21866) -expr_containers(#23040,#23037) -literals("x","x",#23040) -decl(#23040,#23039) -#23041=@"var;{arguments};{#23038}" -variables(#23041,"arguments",#23038) -is_arguments_object(#23041) -#23042=* -typeexprs(#23042,2,#23037,-3,"void") -hasLocation(#23042,#21878) -expr_containers(#23042,#23037) -literals("void","void",#23042) +exprs(#23038,9,#23036,0,"(x: infer U) => void") +hasLocation(#23038,#23037) +enclosing_stmt(#23038,#23006) +expr_containers(#23038,#22805) +#23039=* +scopes(#23039,1) +scopenodes(#23038,#23039) +scopenesting(#23039,#23009) +#23040=@"var;{x};{#23039}" +variables(#23040,"x",#23039) +#23041=* +exprs(#23041,78,#23038,0,"x") +hasLocation(#23041,#21866) +expr_containers(#23041,#23038) +literals("x","x",#23041) +decl(#23041,#23040) +#23042=@"var;{arguments};{#23039}" +variables(#23042,"arguments",#23039) +is_arguments_object(#23042) #23043=* -typeexprs(#23043,29,#23037,-6,"infer U") -#23044=@"loc,{#10000},90,61,90,67" -locations_default(#23044,#10000,90,61,90,67) -hasLocation(#23043,#23044) -expr_containers(#23043,#23037) -#23045=* -typeexprs(#23045,22,#23043,0,"U") -hasLocation(#23045,#21872) -expr_containers(#23045,#23037) +typeexprs(#23043,2,#23038,-3,"void") +hasLocation(#23043,#21878) +expr_containers(#23043,#23038) +literals("void","void",#23043) +#23044=* +typeexprs(#23044,29,#23038,-6,"infer U") +#23045=@"loc,{#10000},90,61,90,67" +locations_default(#23045,#10000,90,61,90,67) +hasLocation(#23044,#23045) +expr_containers(#23044,#23038) #23046=* -typeexprs(#23046,1,#23045,0,"U") +typeexprs(#23046,22,#23044,0,"U") hasLocation(#23046,#21872) -expr_containers(#23046,#23037) -literals("U","U",#23046) +expr_containers(#23046,#23038) #23047=* -typeexprs(#23047,0,#23012,2,"U") -hasLocation(#23047,#21884) -enclosing_stmt(#23047,#23005) -expr_containers(#23047,#22805) +typeexprs(#23047,1,#23046,0,"U") +hasLocation(#23047,#21872) +expr_containers(#23047,#23038) literals("U","U",#23047) #23048=* -typeexprs(#23048,2,#23012,3,"never") -hasLocation(#23048,#21888) -enclosing_stmt(#23048,#23005) +typeexprs(#23048,0,#23013,2,"U") +hasLocation(#23048,#21884) +enclosing_stmt(#23048,#23006) expr_containers(#23048,#22805) -literals("never","never",#23048) +literals("U","U",#23048) #23049=* -stmts(#23049,35,#22805,11,"type T2 ... oid }>;") -#23050=@"loc,{#10000},91,3,91,69" -locations_default(#23050,#10000,91,3,91,69) -hasLocation(#23049,#23050) -stmt_containers(#23049,#22805) -#23051=* -typeexprs(#23051,1,#23049,0,"T20") -hasLocation(#23051,#21894) -enclosing_stmt(#23051,#23049) -expr_containers(#23051,#22805) -literals("T20","T20",#23051) -typedecl(#23051,#22820) +typeexprs(#23049,2,#23013,3,"never") +hasLocation(#23049,#21888) +enclosing_stmt(#23049,#23006) +expr_containers(#23049,#22805) +literals("never","never",#23049) +#23050=* +stmts(#23050,35,#22805,11,"type T2 ... oid }>;") +#23051=@"loc,{#10000},91,3,91,69" +locations_default(#23051,#10000,91,3,91,69) +hasLocation(#23050,#23051) +stmt_containers(#23050,#22805) #23052=* -typeexprs(#23052,14,#23049,1,"Bar<{ a ... void }>") -#23053=@"loc,{#10000},91,14,91,68" -locations_default(#23053,#10000,91,14,91,68) -hasLocation(#23052,#23053) -enclosing_stmt(#23052,#23049) +typeexprs(#23052,1,#23050,0,"T20") +hasLocation(#23052,#21894) +enclosing_stmt(#23052,#23050) expr_containers(#23052,#22805) -#23054=* -typeexprs(#23054,0,#23052,-1,"Bar") -hasLocation(#23054,#21898) -enclosing_stmt(#23054,#23049) -expr_containers(#23054,#22805) -literals("Bar","Bar",#23054) -typebind(#23054,#22819) +literals("T20","T20",#23052) +typedecl(#23052,#22821) +#23053=* +typeexprs(#23053,14,#23050,1,"Bar<{ a ... void }>") +#23054=@"loc,{#10000},91,14,91,68" +locations_default(#23054,#10000,91,14,91,68) +hasLocation(#23053,#23054) +enclosing_stmt(#23053,#23050) +expr_containers(#23053,#22805) #23055=* -typeexprs(#23055,21,#23052,0,"{ a: (x ... void }") -#23056=@"loc,{#10000},91,18,91,67" -locations_default(#23056,#10000,91,18,91,67) -hasLocation(#23055,#23056) -enclosing_stmt(#23055,#23049) +typeexprs(#23055,0,#23053,-1,"Bar") +hasLocation(#23055,#21898) +enclosing_stmt(#23055,#23050) expr_containers(#23055,#22805) -#23057=* -properties(#23057,#23055,0,8,"a: (x: ... > void,") -#23058=@"loc,{#10000},91,20,91,42" -locations_default(#23058,#10000,91,20,91,42) -hasLocation(#23057,#23058) -#23059=* -exprs(#23059,0,#23057,0,"a") -hasLocation(#23059,#21904) -enclosing_stmt(#23059,#23049) -expr_containers(#23059,#22805) -literals("a","a",#23059) -is_abstract_member(#23057) +literals("Bar","Bar",#23055) +typebind(#23055,#22820) +#23056=* +typeexprs(#23056,21,#23053,0,"{ a: (x ... void }") +#23057=@"loc,{#10000},91,18,91,67" +locations_default(#23057,#10000,91,18,91,67) +hasLocation(#23056,#23057) +enclosing_stmt(#23056,#23050) +expr_containers(#23056,#22805) +#23058=* +properties(#23058,#23056,0,8,"a: (x: ... > void,") +#23059=@"loc,{#10000},91,20,91,42" +locations_default(#23059,#10000,91,20,91,42) +hasLocation(#23058,#23059) #23060=* -typeexprs(#23060,23,#23057,2,"(x: string) => void") -#23061=@"loc,{#10000},91,23,91,41" -locations_default(#23061,#10000,91,23,91,41) -hasLocation(#23060,#23061) -enclosing_stmt(#23060,#23049) +exprs(#23060,0,#23058,0,"a") +hasLocation(#23060,#21904) +enclosing_stmt(#23060,#23050) expr_containers(#23060,#22805) -#23062=* -exprs(#23062,9,#23060,0,"(x: string) => void") -hasLocation(#23062,#23061) -enclosing_stmt(#23062,#23049) -expr_containers(#23062,#22805) +literals("a","a",#23060) +is_abstract_member(#23058) +#23061=* +typeexprs(#23061,23,#23058,2,"(x: string) => void") +#23062=@"loc,{#10000},91,23,91,41" +locations_default(#23062,#10000,91,23,91,41) +hasLocation(#23061,#23062) +enclosing_stmt(#23061,#23050) +expr_containers(#23061,#22805) #23063=* -scopes(#23063,1) -scopenodes(#23062,#23063) -scopenesting(#23063,#22808) -#23064=@"var;{x};{#23063}" -variables(#23064,"x",#23063) -#23065=* -exprs(#23065,78,#23062,0,"x") -hasLocation(#23065,#21910) -expr_containers(#23065,#23062) -literals("x","x",#23065) -decl(#23065,#23064) -#23066=@"var;{arguments};{#23063}" -variables(#23066,"arguments",#23063) -is_arguments_object(#23066) -#23067=* -typeexprs(#23067,2,#23062,-3,"void") -hasLocation(#23067,#21920) -expr_containers(#23067,#23062) -literals("void","void",#23067) +exprs(#23063,9,#23061,0,"(x: string) => void") +hasLocation(#23063,#23062) +enclosing_stmt(#23063,#23050) +expr_containers(#23063,#22805) +#23064=* +scopes(#23064,1) +scopenodes(#23063,#23064) +scopenesting(#23064,#22808) +#23065=@"var;{x};{#23064}" +variables(#23065,"x",#23064) +#23066=* +exprs(#23066,78,#23063,0,"x") +hasLocation(#23066,#21910) +expr_containers(#23066,#23063) +literals("x","x",#23066) +decl(#23066,#23065) +#23067=@"var;{arguments};{#23064}" +variables(#23067,"arguments",#23064) +is_arguments_object(#23067) #23068=* -typeexprs(#23068,2,#23062,-6,"string") -hasLocation(#23068,#21914) -expr_containers(#23068,#23062) -literals("string","string",#23068) +typeexprs(#23068,2,#23063,-3,"void") +hasLocation(#23068,#21920) +expr_containers(#23068,#23063) +literals("void","void",#23068) #23069=* -properties(#23069,#23055,1,8,"b: (x: ... => void") -#23070=@"loc,{#10000},91,44,91,65" -locations_default(#23070,#10000,91,44,91,65) -hasLocation(#23069,#23070) -#23071=* -exprs(#23071,0,#23069,0,"b") -hasLocation(#23071,#21924) -enclosing_stmt(#23071,#23049) -expr_containers(#23071,#22805) -literals("b","b",#23071) -is_abstract_member(#23069) +typeexprs(#23069,2,#23063,-6,"string") +hasLocation(#23069,#21914) +expr_containers(#23069,#23063) +literals("string","string",#23069) +#23070=* +properties(#23070,#23056,1,8,"b: (x: ... => void") +#23071=@"loc,{#10000},91,44,91,65" +locations_default(#23071,#10000,91,44,91,65) +hasLocation(#23070,#23071) #23072=* -typeexprs(#23072,23,#23069,2,"(x: string) => void") -#23073=@"loc,{#10000},91,47,91,65" -locations_default(#23073,#10000,91,47,91,65) -hasLocation(#23072,#23073) -enclosing_stmt(#23072,#23049) +exprs(#23072,0,#23070,0,"b") +hasLocation(#23072,#21924) +enclosing_stmt(#23072,#23050) expr_containers(#23072,#22805) -#23074=* -exprs(#23074,9,#23072,0,"(x: string) => void") -hasLocation(#23074,#23073) -enclosing_stmt(#23074,#23049) -expr_containers(#23074,#22805) +literals("b","b",#23072) +is_abstract_member(#23070) +#23073=* +typeexprs(#23073,23,#23070,2,"(x: string) => void") +#23074=@"loc,{#10000},91,47,91,65" +locations_default(#23074,#10000,91,47,91,65) +hasLocation(#23073,#23074) +enclosing_stmt(#23073,#23050) +expr_containers(#23073,#22805) #23075=* -scopes(#23075,1) -scopenodes(#23074,#23075) -scopenesting(#23075,#22808) -#23076=@"var;{x};{#23075}" -variables(#23076,"x",#23075) -#23077=* -exprs(#23077,78,#23074,0,"x") -hasLocation(#23077,#21930) -expr_containers(#23077,#23074) -literals("x","x",#23077) -decl(#23077,#23076) -#23078=@"var;{arguments};{#23075}" -variables(#23078,"arguments",#23075) -is_arguments_object(#23078) -#23079=* -typeexprs(#23079,2,#23074,-3,"void") -hasLocation(#23079,#21940) -expr_containers(#23079,#23074) -literals("void","void",#23079) +exprs(#23075,9,#23073,0,"(x: string) => void") +hasLocation(#23075,#23074) +enclosing_stmt(#23075,#23050) +expr_containers(#23075,#22805) +#23076=* +scopes(#23076,1) +scopenodes(#23075,#23076) +scopenesting(#23076,#22808) +#23077=@"var;{x};{#23076}" +variables(#23077,"x",#23076) +#23078=* +exprs(#23078,78,#23075,0,"x") +hasLocation(#23078,#21930) +expr_containers(#23078,#23075) +literals("x","x",#23078) +decl(#23078,#23077) +#23079=@"var;{arguments};{#23076}" +variables(#23079,"arguments",#23076) +is_arguments_object(#23079) #23080=* -typeexprs(#23080,2,#23074,-6,"string") -hasLocation(#23080,#21934) -expr_containers(#23080,#23074) -literals("string","string",#23080) +typeexprs(#23080,2,#23075,-3,"void") +hasLocation(#23080,#21940) +expr_containers(#23080,#23075) +literals("void","void",#23080) #23081=* -stmts(#23081,35,#22805,12,"type T2 ... oid }>;") -#23082=@"loc,{#10000},92,3,92,69" -locations_default(#23082,#10000,92,3,92,69) -hasLocation(#23081,#23082) -stmt_containers(#23081,#22805) -#23083=* -typeexprs(#23083,1,#23081,0,"T21") -hasLocation(#23083,#21950) -enclosing_stmt(#23083,#23081) -expr_containers(#23083,#22805) -literals("T21","T21",#23083) -typedecl(#23083,#22821) +typeexprs(#23081,2,#23075,-6,"string") +hasLocation(#23081,#21934) +expr_containers(#23081,#23075) +literals("string","string",#23081) +#23082=* +stmts(#23082,35,#22805,12,"type T2 ... oid }>;") +#23083=@"loc,{#10000},92,3,92,69" +locations_default(#23083,#10000,92,3,92,69) +hasLocation(#23082,#23083) +stmt_containers(#23082,#22805) #23084=* -typeexprs(#23084,14,#23081,1,"Bar<{ a ... void }>") -#23085=@"loc,{#10000},92,14,92,68" -locations_default(#23085,#10000,92,14,92,68) -hasLocation(#23084,#23085) -enclosing_stmt(#23084,#23081) +typeexprs(#23084,1,#23082,0,"T21") +hasLocation(#23084,#21950) +enclosing_stmt(#23084,#23082) expr_containers(#23084,#22805) -#23086=* -typeexprs(#23086,0,#23084,-1,"Bar") -hasLocation(#23086,#21954) -enclosing_stmt(#23086,#23081) -expr_containers(#23086,#22805) -literals("Bar","Bar",#23086) -typebind(#23086,#22819) +literals("T21","T21",#23084) +typedecl(#23084,#22822) +#23085=* +typeexprs(#23085,14,#23082,1,"Bar<{ a ... void }>") +#23086=@"loc,{#10000},92,14,92,68" +locations_default(#23086,#10000,92,14,92,68) +hasLocation(#23085,#23086) +enclosing_stmt(#23085,#23082) +expr_containers(#23085,#22805) #23087=* -typeexprs(#23087,21,#23084,0,"{ a: (x ... void }") -#23088=@"loc,{#10000},92,18,92,67" -locations_default(#23088,#10000,92,18,92,67) -hasLocation(#23087,#23088) -enclosing_stmt(#23087,#23081) +typeexprs(#23087,0,#23085,-1,"Bar") +hasLocation(#23087,#21954) +enclosing_stmt(#23087,#23082) expr_containers(#23087,#22805) -#23089=* -properties(#23089,#23087,0,8,"a: (x: ... > void,") -#23090=@"loc,{#10000},92,20,92,42" -locations_default(#23090,#10000,92,20,92,42) -hasLocation(#23089,#23090) -#23091=* -exprs(#23091,0,#23089,0,"a") -hasLocation(#23091,#21960) -enclosing_stmt(#23091,#23081) -expr_containers(#23091,#22805) -literals("a","a",#23091) -is_abstract_member(#23089) +literals("Bar","Bar",#23087) +typebind(#23087,#22820) +#23088=* +typeexprs(#23088,21,#23085,0,"{ a: (x ... void }") +#23089=@"loc,{#10000},92,18,92,67" +locations_default(#23089,#10000,92,18,92,67) +hasLocation(#23088,#23089) +enclosing_stmt(#23088,#23082) +expr_containers(#23088,#22805) +#23090=* +properties(#23090,#23088,0,8,"a: (x: ... > void,") +#23091=@"loc,{#10000},92,20,92,42" +locations_default(#23091,#10000,92,20,92,42) +hasLocation(#23090,#23091) #23092=* -typeexprs(#23092,23,#23089,2,"(x: string) => void") -#23093=@"loc,{#10000},92,23,92,41" -locations_default(#23093,#10000,92,23,92,41) -hasLocation(#23092,#23093) -enclosing_stmt(#23092,#23081) +exprs(#23092,0,#23090,0,"a") +hasLocation(#23092,#21960) +enclosing_stmt(#23092,#23082) expr_containers(#23092,#22805) -#23094=* -exprs(#23094,9,#23092,0,"(x: string) => void") -hasLocation(#23094,#23093) -enclosing_stmt(#23094,#23081) -expr_containers(#23094,#22805) +literals("a","a",#23092) +is_abstract_member(#23090) +#23093=* +typeexprs(#23093,23,#23090,2,"(x: string) => void") +#23094=@"loc,{#10000},92,23,92,41" +locations_default(#23094,#10000,92,23,92,41) +hasLocation(#23093,#23094) +enclosing_stmt(#23093,#23082) +expr_containers(#23093,#22805) #23095=* -scopes(#23095,1) -scopenodes(#23094,#23095) -scopenesting(#23095,#22808) -#23096=@"var;{x};{#23095}" -variables(#23096,"x",#23095) -#23097=* -exprs(#23097,78,#23094,0,"x") -hasLocation(#23097,#21966) -expr_containers(#23097,#23094) -literals("x","x",#23097) -decl(#23097,#23096) -#23098=@"var;{arguments};{#23095}" -variables(#23098,"arguments",#23095) -is_arguments_object(#23098) -#23099=* -typeexprs(#23099,2,#23094,-3,"void") -hasLocation(#23099,#21976) -expr_containers(#23099,#23094) -literals("void","void",#23099) +exprs(#23095,9,#23093,0,"(x: string) => void") +hasLocation(#23095,#23094) +enclosing_stmt(#23095,#23082) +expr_containers(#23095,#22805) +#23096=* +scopes(#23096,1) +scopenodes(#23095,#23096) +scopenesting(#23096,#22808) +#23097=@"var;{x};{#23096}" +variables(#23097,"x",#23096) +#23098=* +exprs(#23098,78,#23095,0,"x") +hasLocation(#23098,#21966) +expr_containers(#23098,#23095) +literals("x","x",#23098) +decl(#23098,#23097) +#23099=@"var;{arguments};{#23096}" +variables(#23099,"arguments",#23096) +is_arguments_object(#23099) #23100=* -typeexprs(#23100,2,#23094,-6,"string") -hasLocation(#23100,#21970) -expr_containers(#23100,#23094) -literals("string","string",#23100) +typeexprs(#23100,2,#23095,-3,"void") +hasLocation(#23100,#21976) +expr_containers(#23100,#23095) +literals("void","void",#23100) #23101=* -properties(#23101,#23087,1,8,"b: (x: ... => void") -#23102=@"loc,{#10000},92,44,92,65" -locations_default(#23102,#10000,92,44,92,65) -hasLocation(#23101,#23102) -#23103=* -exprs(#23103,0,#23101,0,"b") -hasLocation(#23103,#21980) -enclosing_stmt(#23103,#23081) -expr_containers(#23103,#22805) -literals("b","b",#23103) -is_abstract_member(#23101) +typeexprs(#23101,2,#23095,-6,"string") +hasLocation(#23101,#21970) +expr_containers(#23101,#23095) +literals("string","string",#23101) +#23102=* +properties(#23102,#23088,1,8,"b: (x: ... => void") +#23103=@"loc,{#10000},92,44,92,65" +locations_default(#23103,#10000,92,44,92,65) +hasLocation(#23102,#23103) #23104=* -typeexprs(#23104,23,#23101,2,"(x: number) => void") -#23105=@"loc,{#10000},92,47,92,65" -locations_default(#23105,#10000,92,47,92,65) -hasLocation(#23104,#23105) -enclosing_stmt(#23104,#23081) +exprs(#23104,0,#23102,0,"b") +hasLocation(#23104,#21980) +enclosing_stmt(#23104,#23082) expr_containers(#23104,#22805) -#23106=* -exprs(#23106,9,#23104,0,"(x: number) => void") -hasLocation(#23106,#23105) -enclosing_stmt(#23106,#23081) -expr_containers(#23106,#22805) +literals("b","b",#23104) +is_abstract_member(#23102) +#23105=* +typeexprs(#23105,23,#23102,2,"(x: number) => void") +#23106=@"loc,{#10000},92,47,92,65" +locations_default(#23106,#10000,92,47,92,65) +hasLocation(#23105,#23106) +enclosing_stmt(#23105,#23082) +expr_containers(#23105,#22805) #23107=* -scopes(#23107,1) -scopenodes(#23106,#23107) -scopenesting(#23107,#22808) -#23108=@"var;{x};{#23107}" -variables(#23108,"x",#23107) -#23109=* -exprs(#23109,78,#23106,0,"x") -hasLocation(#23109,#21986) -expr_containers(#23109,#23106) -literals("x","x",#23109) -decl(#23109,#23108) -#23110=@"var;{arguments};{#23107}" -variables(#23110,"arguments",#23107) -is_arguments_object(#23110) -#23111=* -typeexprs(#23111,2,#23106,-3,"void") -hasLocation(#23111,#21996) -expr_containers(#23111,#23106) -literals("void","void",#23111) +exprs(#23107,9,#23105,0,"(x: number) => void") +hasLocation(#23107,#23106) +enclosing_stmt(#23107,#23082) +expr_containers(#23107,#22805) +#23108=* +scopes(#23108,1) +scopenodes(#23107,#23108) +scopenesting(#23108,#22808) +#23109=@"var;{x};{#23108}" +variables(#23109,"x",#23108) +#23110=* +exprs(#23110,78,#23107,0,"x") +hasLocation(#23110,#21986) +expr_containers(#23110,#23107) +literals("x","x",#23110) +decl(#23110,#23109) +#23111=@"var;{arguments};{#23108}" +variables(#23111,"arguments",#23108) +is_arguments_object(#23111) #23112=* -typeexprs(#23112,2,#23106,-6,"number") -hasLocation(#23112,#21990) -expr_containers(#23112,#23106) -literals("number","number",#23112) +typeexprs(#23112,2,#23107,-3,"void") +hasLocation(#23112,#21996) +expr_containers(#23112,#23107) +literals("void","void",#23112) #23113=* -stmts(#23113,17,#22805,13,"declare ... number;") -#23114=@"loc,{#10000},94,3,94,42" -locations_default(#23114,#10000,94,3,94,42) -hasLocation(#23113,#23114) -stmt_containers(#23113,#22805) -has_declare_keyword(#23113) -#23115=* -exprs(#23115,78,#23113,-1,"foo") -hasLocation(#23115,#22008) -expr_containers(#23115,#23113) -literals("foo","foo",#23115) -#23116=@"var;{foo};{#20000}" -variables(#23116,"foo",#20000) -decl(#23115,#23116) +typeexprs(#23113,2,#23107,-6,"number") +hasLocation(#23113,#21990) +expr_containers(#23113,#23107) +literals("number","number",#23113) +#23114=* +stmts(#23114,17,#22805,13,"declare ... number;") +#23115=@"loc,{#10000},94,3,94,42" +locations_default(#23115,#10000,94,3,94,42) +hasLocation(#23114,#23115) +stmt_containers(#23114,#22805) +has_declare_keyword(#23114) +#23116=* +exprs(#23116,78,#23114,-1,"foo") +hasLocation(#23116,#22008) +expr_containers(#23116,#23114) +literals("foo","foo",#23116) +decl(#23116,#22809) #23117=* scopes(#23117,1) -scopenodes(#23113,#23117) +scopenodes(#23114,#23117) scopenesting(#23117,#22808) #23118=@"var;{x};{#23117}" variables(#23118,"x",#23117) #23119=* -exprs(#23119,78,#23113,0,"x") +exprs(#23119,78,#23114,0,"x") hasLocation(#23119,#22012) -expr_containers(#23119,#23113) +expr_containers(#23119,#23114) literals("x","x",#23119) decl(#23119,#23118) #23120=@"var;{arguments};{#23117}" variables(#23120,"arguments",#23117) is_arguments_object(#23120) #23121=* -typeexprs(#23121,2,#23113,-3,"number") +typeexprs(#23121,2,#23114,-3,"number") hasLocation(#23121,#22022) -expr_containers(#23121,#23113) +expr_containers(#23121,#23114) literals("number","number",#23121) #23122=* -typeexprs(#23122,2,#23113,-6,"string") +typeexprs(#23122,2,#23114,-6,"string") hasLocation(#23122,#22016) -expr_containers(#23122,#23113) +expr_containers(#23122,#23114) literals("string","string",#23122) #23123=* stmts(#23123,17,#22805,14,"declare ... string;") @@ -9757,7 +9757,7 @@ exprs(#23125,78,#23123,-1,"foo") hasLocation(#23125,#22030) expr_containers(#23125,#23123) literals("foo","foo",#23125) -decl(#23125,#23116) +decl(#23125,#22809) #23126=* scopes(#23126,1) scopenodes(#23123,#23126) @@ -9795,7 +9795,7 @@ exprs(#23134,78,#23132,-1,"foo") hasLocation(#23134,#22052) expr_containers(#23134,#23132) literals("foo","foo",#23134) -decl(#23134,#23116) +decl(#23134,#22809) #23135=* scopes(#23135,1) scopenodes(#23132,#23135) @@ -9855,7 +9855,7 @@ hasLocation(#23149,#22080) enclosing_stmt(#23149,#23147) expr_containers(#23149,#22805) literals("T30","T30",#23149) -typedecl(#23149,#22822) +typedecl(#23149,#22823) #23150=* typeexprs(#23150,14,#23147,1,"ReturnT ... of foo>") #23151=@"loc,{#10000},97,14,97,35" @@ -9869,7 +9869,7 @@ hasLocation(#23152,#22084) enclosing_stmt(#23152,#23147) expr_containers(#23152,#22805) literals("ReturnType","ReturnType",#23152) -typebind(#23152,#22824) +typebind(#23152,#22825) #23153=* typeexprs(#23153,16,#23150,0,"typeof foo") #23154=@"loc,{#10000},97,25,97,34" @@ -9883,7 +9883,7 @@ hasLocation(#23155,#22090) enclosing_stmt(#23155,#23147) expr_containers(#23155,#22805) literals("foo","foo",#23155) -bind(#23155,#23116) +bind(#23155,#22809) #23156=* stmts(#23156,35,#22805,17,"type An ... => any;") #23157=@"loc,{#10000},99,3,99,45" @@ -9896,7 +9896,7 @@ hasLocation(#23158,#22098) enclosing_stmt(#23158,#23156) expr_containers(#23158,#22805) literals("AnyFunction","AnyFunction",#23158) -typedecl(#23158,#22823) +typedecl(#23158,#22824) #23159=* typeexprs(#23159,23,#23156,1,"(...arg ... => any") #23160=@"loc,{#10000},99,22,99,44" @@ -9953,7 +9953,7 @@ hasLocation(#23172,#22126) enclosing_stmt(#23172,#23170) expr_containers(#23172,#22805) literals("ReturnType","ReturnType",#23172) -typedecl(#23172,#22824) +typedecl(#23172,#22825) #23173=* scopes(#23173,12) scopenodes(#23170,#23173) @@ -9980,7 +9980,7 @@ hasLocation(#23178,#22134) enclosing_stmt(#23178,#23170) expr_containers(#23178,#22805) literals("AnyFunction","AnyFunction",#23178) -typebind(#23178,#22823) +typebind(#23178,#22824) #23179=* typeexprs(#23179,28,#23170,1,"T exten ... R : any") #23180=@"loc,{#10000},100,44,100,90" @@ -10084,21 +10084,21 @@ successor(#23156,#23170) successor(#23147,#23156) successor(#23132,#23147) successor(#23123,#23132) -successor(#23113,#23123) -successor(#23081,#23113) -successor(#23049,#23081) -successor(#23005,#23049) -successor(#22989,#23005) -successor(#22973,#22989) -successor(#22945,#22973) -successor(#22930,#22945) -successor(#22918,#22930) -successor(#22908,#22918) -successor(#22896,#22908) -successor(#22887,#22896) -successor(#22880,#22887) -successor(#22825,#22880) -successor(#22805,#22825) +successor(#23114,#23123) +successor(#23082,#23114) +successor(#23050,#23082) +successor(#23006,#23050) +successor(#22990,#23006) +successor(#22974,#22990) +successor(#22946,#22974) +successor(#22931,#22946) +successor(#22919,#22931) +successor(#22909,#22919) +successor(#22897,#22909) +successor(#22888,#22897) +successor(#22881,#22888) +successor(#22826,#22881) +successor(#22805,#22826) successor(#22185,#22183) successor(#22777,#22807) successor(#22770,#22777) diff --git a/javascript/extractor/tests/ts/output/trap/declareClass.ts.trap b/javascript/extractor/tests/ts/output/trap/declareClass.ts.trap index 6bc9fb5ffb25..83ada22ef89a 100644 --- a/javascript/extractor/tests/ts/output/trap/declareClass.ts.trap +++ b/javascript/extractor/tests/ts/output/trap/declareClass.ts.trap @@ -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") diff --git a/javascript/extractor/tests/ts/output/trap/functiondecorators.ts.trap b/javascript/extractor/tests/ts/output/trap/functiondecorators.ts.trap index 89cd17604433..00276bb64641 100644 --- a/javascript/extractor/tests/ts/output/trap/functiondecorators.ts.trap +++ b/javascript/extractor/tests/ts/output/trap/functiondecorators.ts.trap @@ -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") diff --git a/javascript/extractor/tests/ts/output/trap/nobody.ts.trap b/javascript/extractor/tests/ts/output/trap/nobody.ts.trap index 44a32603e097..717d79423abd 100644 --- a/javascript/extractor/tests/ts/output/trap/nobody.ts.trap +++ b/javascript/extractor/tests/ts/output/trap/nobody.ts.trap @@ -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") diff --git a/javascript/extractor/tests/ts/output/trap/thisparameter.ts.trap b/javascript/extractor/tests/ts/output/trap/thisparameter.ts.trap index 0e766cf77b99..27b075f05c76 100644 --- a/javascript/extractor/tests/ts/output/trap/thisparameter.ts.trap +++ b/javascript/extractor/tests/ts/output/trap/thisparameter.ts.trap @@ -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") diff --git a/javascript/ql/integration-tests/no-types/foo.ts b/javascript/ql/integration-tests/no-types/foo.ts deleted file mode 100644 index a443ec59b123..000000000000 --- a/javascript/ql/integration-tests/no-types/foo.ts +++ /dev/null @@ -1 +0,0 @@ -export const foo: { bar: number } = { bar: 42}; \ No newline at end of file diff --git a/javascript/ql/integration-tests/no-types/javascript.expected b/javascript/ql/integration-tests/no-types/javascript.expected deleted file mode 100644 index e69de29bb2d1..000000000000 diff --git a/javascript/ql/integration-tests/no-types/javascript.ql b/javascript/ql/integration-tests/no-types/javascript.ql deleted file mode 100644 index 9bb497c687c4..000000000000 --- a/javascript/ql/integration-tests/no-types/javascript.ql +++ /dev/null @@ -1,5 +0,0 @@ -import javascript - -from Expr e, Type t -where t = e.getType() -select e, t diff --git a/javascript/ql/integration-tests/no-types/test.py b/javascript/ql/integration-tests/no-types/test.py deleted file mode 100755 index 2c3862227aa9..000000000000 --- a/javascript/ql/integration-tests/no-types/test.py +++ /dev/null @@ -1,2 +0,0 @@ -def test(codeql, javascript): - codeql.database.create(extractor_option="skip_types=true") diff --git a/javascript/ql/integration-tests/no-types/tsconfig.json b/javascript/ql/integration-tests/no-types/tsconfig.json deleted file mode 100644 index 9e26dfeeb6e6..000000000000 --- a/javascript/ql/integration-tests/no-types/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{} \ No newline at end of file diff --git a/javascript/ql/integration-tests/query-suite/not_included_in_qls.expected b/javascript/ql/integration-tests/query-suite/not_included_in_qls.expected index a6c808c6cbfb..e38e7aa19dd1 100644 --- a/javascript/ql/integration-tests/query-suite/not_included_in_qls.expected +++ b/javascript/ql/integration-tests/query-suite/not_included_in_qls.expected @@ -144,5 +144,3 @@ ql/javascript/ql/src/meta/analysis-quality/UnresolvableImports.ql ql/javascript/ql/src/meta/extraction-metrics/FileData.ql ql/javascript/ql/src/meta/extraction-metrics/MissingMetrics.ql ql/javascript/ql/src/meta/extraction-metrics/PhaseTimings.ql -ql/javascript/ql/src/meta/types/TypedExprs.ql -ql/javascript/ql/src/meta/types/TypesWithQualifiedName.ql diff --git a/javascript/ql/lib/definitions.qll b/javascript/ql/lib/definitions.qll index 2cc9313d3132..54ad0c3548a6 100644 --- a/javascript/ql/lib/definitions.qll +++ b/javascript/ql/lib/definitions.qll @@ -126,7 +126,7 @@ private predicate propertyLookup(Expr prop, AstNode write, string kind) { private predicate typeLookup(AstNode ref, AstNode decl, string kind) { exists(TypeAccess typeAccess | ref = typeAccess.getIdentifier() and - decl = typeAccess.getTypeName().getADefinition() and + decl = typeAccess.getTypeBinding().getTypeDefinition() and kind = "T" ) } @@ -153,17 +153,7 @@ private predicate jsdocTypeLookup(JSDocNamedTypeExpr ref, AstNode decl, string k kind = "T" } -/** - * Gets an element, of kind `kind`, that element `e` uses, if any. - * - * The `kind` is a string representing what kind of use it is: - * - `"M"` for function and method calls - * - `"T"` for uses of types - * - `"V"` for variable accesses - * - `"I"` for imports - */ -cached -AstNode definitionOf(Locatable e, string kind) { +private AstNode definitionOfRaw(Locatable e, string kind) { variableDefLookup(e, result, kind) or // prefer definitions over declarations @@ -179,3 +169,46 @@ AstNode definitionOf(Locatable e, string kind) { or jsdocTypeLookup(e, result, kind) } + +/** Gets a more useful node to show for something that resolves to `node`. */ +private AstNode redirectOnce(AstNode node) { + exists(ConstructorDeclaration ctor | + ctor.isSynthetic() and + node = ctor.getBody() and + result = ctor.getDeclaringClass() + ) + or + exists(ClassDefinition cls | + node = cls and + result = cls.getIdentifier() + ) + or + exists(FunctionDeclStmt decl | + node = decl and + result = decl.getIdentifier() + ) + or + exists(MethodDeclaration member | + not member instanceof ConstructorDeclaration and + node = member.getBody() and + result = member.getNameExpr() + ) +} + +private AstNode redirect(AstNode node) { + node = definitionOfRaw(_, _) and + result = redirectOnce*(node) and + not exists(redirectOnce(result)) +} + +/** + * Gets an element, of kind `kind`, that element `e` uses, if any. + * + * The `kind` is a string representing what kind of use it is: + * - `"M"` for function and method calls + * - `"T"` for uses of types + * - `"V"` for variable accesses + * - `"I"` for imports + */ +cached +AstNode definitionOf(Locatable e, string kind) { result = redirect(definitionOfRaw(e, kind)) } diff --git a/javascript/ql/lib/javascript.qll b/javascript/ql/lib/javascript.qll index d75eed29b8e0..46f35dee84fb 100644 --- a/javascript/ql/lib/javascript.qll +++ b/javascript/ql/lib/javascript.qll @@ -47,7 +47,7 @@ import semmle.javascript.NodeJS import semmle.javascript.NPM import semmle.javascript.Paths import semmle.javascript.Promises -import semmle.javascript.CanonicalNames +deprecated import semmle.javascript.CanonicalNames import semmle.javascript.RangeAnalysis import semmle.javascript.Regexp import semmle.javascript.Routing diff --git a/javascript/ql/lib/semmle/javascript/AST.qll b/javascript/ql/lib/semmle/javascript/AST.qll index 90b8494d1663..bcde7bbaf4a2 100644 --- a/javascript/ql/lib/semmle/javascript/AST.qll +++ b/javascript/ql/lib/semmle/javascript/AST.qll @@ -5,6 +5,8 @@ import javascript private import internal.StmtContainers private import semmle.javascript.internal.CachedStages +private import semmle.javascript.internal.TypeResolution +private import semmle.javascript.internal.BindingInfo /** * A program element corresponding to JavaScript code, such as an expression @@ -472,5 +474,22 @@ module AST { /** Gets the data flow node associated with this program element. */ DataFlow::ValueNode flow() { result = DataFlow::valueNode(this) } + + /** + * Gets information about the results of name-resolution for this expression. + * + * This can be used to map an expression to the class it refers to, or + * associate it with a named value coming from an dependency. + */ + ExprNameBindingNode getNameBinding() { result = this } + + /** + * Gets information about the type of this expression. + * + * This can be used to map an expression to the classes it may be an instance of + * (according to the type system), or to associate it with a named type coming + * from a dependency. + */ + TypeNameBindingNode getTypeBinding() { TypeResolution::valueHasType(this, result) } } } diff --git a/javascript/ql/lib/semmle/javascript/ApiGraphs.qll b/javascript/ql/lib/semmle/javascript/ApiGraphs.qll index 3e882251cbf7..3bb04f2686be 100644 --- a/javascript/ql/lib/semmle/javascript/ApiGraphs.qll +++ b/javascript/ql/lib/semmle/javascript/ApiGraphs.qll @@ -649,11 +649,13 @@ module API { /** Gets a node corresponding to an import of module `m` without taking into account types from models. */ Node getAModuleImportRaw(string m) { result = Impl::MkModuleImport(m) or - result = Impl::MkModuleImport(m).(Node).getMember("default") + result = Impl::MkModuleImport(m).(Node).getMember("default") or + result = Impl::MkTypeUse(m, "") } /** Gets a node whose type has the given qualified name, not including types from models. */ Node getANodeOfTypeRaw(string moduleName, string exportedName) { + exportedName != "" and result = Impl::MkTypeUse(moduleName, exportedName).(Node).getInstance() or exportedName = "" and @@ -749,18 +751,14 @@ module API { MkModuleImport(string m) { imports(_, m) or - any(TypeAnnotation n).hasQualifiedName(m, _) - or - any(Type t).hasUnderlyingType(m, _) + any(TypeAnnotation n).hasUnderlyingType(m, _) } or MkClassInstance(DataFlow::ClassNode cls) { needsDefNode(cls) } or MkDef(DataFlow::Node nd) { rhs(_, _, nd) } or MkUse(DataFlow::Node nd) { use(_, _, nd) } or /** A use of a TypeScript type. */ MkTypeUse(string moduleName, string exportName) { - any(TypeAnnotation n).hasQualifiedName(moduleName, exportName) - or - any(Type t).hasUnderlyingType(moduleName, exportName) + any(TypeAnnotation n).hasUnderlyingType(moduleName, exportName) } or MkSyntheticCallbackArg(DataFlow::Node src, int bound, DataFlow::InvokeNode nd) { trackUseNode(src, true, bound, "").flowsTo(nd.getCalleeNode()) diff --git a/javascript/ql/lib/semmle/javascript/CanonicalNames.qll b/javascript/ql/lib/semmle/javascript/CanonicalNames.qll index d83aeefdc9a5..87f7c25b36de 100644 --- a/javascript/ql/lib/semmle/javascript/CanonicalNames.qll +++ b/javascript/ql/lib/semmle/javascript/CanonicalNames.qll @@ -1,6 +1,7 @@ /** * Provides classes for working with name resolution of namespaces and types. */ +deprecated module; import javascript @@ -18,7 +19,7 @@ import javascript * * This class is only populated when full TypeScript extraction is enabled. */ -class CanonicalName extends @symbol { +deprecated class CanonicalName extends @symbol { /** * Gets the parent of this canonical name, that is, the prefix of its qualified name. */ @@ -218,7 +219,7 @@ class CanonicalName extends @symbol { /** * The canonical name for a type. */ -class TypeName extends CanonicalName { +deprecated class TypeName extends CanonicalName { TypeName() { exists(TypeReference ref | type_symbol(ref, this)) or exists(TypeDefinition def | ast_node_symbol(def, this)) or @@ -261,7 +262,7 @@ class TypeName extends CanonicalName { /** * The canonical name for a namespace. */ -class Namespace extends CanonicalName { +deprecated class Namespace extends CanonicalName { Namespace() { this.getAChild().isExportedMember() or exists(NamespaceDefinition def | ast_node_symbol(def, this)) or @@ -309,7 +310,7 @@ class Namespace extends CanonicalName { /** * The canonical name for a function. */ -class CanonicalFunctionName extends CanonicalName { +deprecated class CanonicalFunctionName extends CanonicalName { CanonicalFunctionName() { exists(Function fun | ast_node_symbol(fun, this)) or exists(InvokeExpr invoke | ast_node_symbol(invoke, this)) diff --git a/javascript/ql/lib/semmle/javascript/Classes.qll b/javascript/ql/lib/semmle/javascript/Classes.qll index f5877a78371b..394ab7910276 100644 --- a/javascript/ql/lib/semmle/javascript/Classes.qll +++ b/javascript/ql/lib/semmle/javascript/Classes.qll @@ -119,7 +119,7 @@ class ClassOrInterface extends @class_or_interface, TypeParameterized { * * Anonymous classes and interfaces do not have a canonical name. */ - TypeName getTypeName() { result.getADefinition() = this } + deprecated TypeName getTypeName() { result.getADefinition() = this } /** * Gets the ClassOrInterface corresponding to either a super type or an implemented interface. diff --git a/javascript/ql/lib/semmle/javascript/Closure.qll b/javascript/ql/lib/semmle/javascript/Closure.qll index 40aee266379c..c31698333393 100644 --- a/javascript/ql/lib/semmle/javascript/Closure.qll +++ b/javascript/ql/lib/semmle/javascript/Closure.qll @@ -5,17 +5,49 @@ import javascript module Closure { + /** A call to `goog.require` */ + class RequireCallExpr extends CallExpr { + RequireCallExpr() { this.getCallee().(PropAccess).getQualifiedName() = "goog.require" } + + /** Gets the imported namespace name. */ + string getClosureNamespace() { result = this.getArgument(0).getStringValue() } + } + + /** A call to `goog.provide` */ + class ProvideCallExpr extends CallExpr { + ProvideCallExpr() { this.getCallee().(PropAccess).getQualifiedName() = "goog.provide" } + + /** Gets the imported namespace name. */ + string getClosureNamespace() { result = this.getArgument(0).getStringValue() } + } + + /** A call to `goog.module` or `goog.declareModuleId`. */ + private class ModuleDeclarationCall extends CallExpr { + private string kind; + + ModuleDeclarationCall() { + this.getCallee().(PropAccess).getQualifiedName() = kind and + kind = ["goog.module", "goog.declareModuleId"] + } + + /** Gets the declared namespace. */ + string getClosureNamespace() { result = this.getArgument(0).getStringValue() } + + /** Gets the string `goog.module` or `goog.declareModuleId` depending on which method is being called. */ + string getModuleKind() { result = kind } + } + /** * A reference to a Closure namespace. */ - class ClosureNamespaceRef extends DataFlow::Node instanceof ClosureNamespaceRef::Range { + deprecated class ClosureNamespaceRef extends DataFlow::Node instanceof ClosureNamespaceRef::Range { /** * Gets the namespace being referenced. */ string getClosureNamespace() { result = super.getClosureNamespace() } } - module ClosureNamespaceRef { + deprecated module ClosureNamespaceRef { /** * A reference to a Closure namespace. * @@ -32,10 +64,10 @@ module Closure { /** * A data flow node that returns the value of a closure namespace. */ - class ClosureNamespaceAccess extends ClosureNamespaceRef instanceof ClosureNamespaceAccess::Range { - } + deprecated class ClosureNamespaceAccess extends ClosureNamespaceRef instanceof ClosureNamespaceAccess::Range + { } - module ClosureNamespaceAccess { + deprecated module ClosureNamespaceAccess { /** * A data flow node that returns the value of a closure namespace. * @@ -47,7 +79,7 @@ module Closure { /** * A call to a method on the `goog.` namespace, as a closure reference. */ - abstract private class DefaultNamespaceRef extends DataFlow::MethodCallNode, + abstract deprecated private class DefaultNamespaceRef extends DataFlow::MethodCallNode, ClosureNamespaceRef::Range { DefaultNamespaceRef() { this = DataFlow::globalVarRef("goog").getAMethodCall() } @@ -59,14 +91,14 @@ module Closure { * Holds if `node` is the data flow node corresponding to the expression in * a top-level expression statement. */ - private predicate isTopLevelExpr(DataFlow::Node node) { + deprecated private predicate isTopLevelExpr(DataFlow::Node node) { any(TopLevel tl).getAChildStmt().(ExprStmt).getExpr().flow() = node } /** * A top-level call to `goog.provide`. */ - private class DefaultClosureProvideCall extends DefaultNamespaceRef { + deprecated private class DefaultClosureProvideCall extends DefaultNamespaceRef { DefaultClosureProvideCall() { this.getMethodName() = "provide" and isTopLevelExpr(this) @@ -76,13 +108,14 @@ module Closure { /** * A top-level call to `goog.provide`. */ - class ClosureProvideCall extends ClosureNamespaceRef, DataFlow::MethodCallNode instanceof DefaultClosureProvideCall + deprecated class ClosureProvideCall extends ClosureNamespaceRef, DataFlow::MethodCallNode instanceof DefaultClosureProvideCall { } /** * A call to `goog.require`. */ - private class DefaultClosureRequireCall extends DefaultNamespaceRef, ClosureNamespaceAccess::Range + deprecated private class DefaultClosureRequireCall extends DefaultNamespaceRef, + ClosureNamespaceAccess::Range { DefaultClosureRequireCall() { this.getMethodName() = "require" } } @@ -90,13 +123,13 @@ module Closure { /** * A call to `goog.require`. */ - class ClosureRequireCall extends ClosureNamespaceAccess, DataFlow::MethodCallNode instanceof DefaultClosureRequireCall + deprecated class ClosureRequireCall extends ClosureNamespaceAccess, DataFlow::MethodCallNode instanceof DefaultClosureRequireCall { } /** * A top-level call to `goog.module` or `goog.declareModuleId`. */ - private class DefaultClosureModuleDeclaration extends DefaultNamespaceRef { + deprecated private class DefaultClosureModuleDeclaration extends DefaultNamespaceRef { DefaultClosureModuleDeclaration() { (this.getMethodName() = "module" or this.getMethodName() = "declareModuleId") and isTopLevelExpr(this) @@ -106,41 +139,29 @@ module Closure { /** * A top-level call to `goog.module` or `goog.declareModuleId`. */ - class ClosureModuleDeclaration extends ClosureNamespaceRef, DataFlow::MethodCallNode instanceof DefaultClosureModuleDeclaration + deprecated class ClosureModuleDeclaration extends ClosureNamespaceRef, DataFlow::MethodCallNode instanceof DefaultClosureModuleDeclaration { } - private GlobalVariable googVariable() { variables(result, "goog", any(GlobalScope sc)) } - - pragma[nomagic] - private MethodCallExpr googModuleDeclExpr() { - result.getReceiver() = googVariable().getAnAccess() and - result.getMethodName() = ["module", "declareModuleId"] - } - - pragma[nomagic] - private MethodCallExpr googModuleDeclExprInContainer(StmtContainer container) { - result = googModuleDeclExpr() and - container = result.getContainer() - } - pragma[noinline] - private ClosureRequireCall getARequireInTopLevel(ClosureModule m) { result.getTopLevel() = m } + private RequireCallExpr getARequireInTopLevel(ClosureModule m) { result.getTopLevel() = m } /** * A module using the Closure module system, declared using `goog.module()` or `goog.declareModuleId()`. */ class ClosureModule extends Module { - ClosureModule() { exists(googModuleDeclExprInContainer(this)) } + private ModuleDeclarationCall decl; + + ClosureModule() { decl.getTopLevel() = this } /** * Gets the call to `goog.module` or `goog.declareModuleId` in this module. */ - ClosureModuleDeclaration getModuleDeclaration() { result.getTopLevel() = this } + deprecated ClosureModuleDeclaration getModuleDeclaration() { result.getTopLevel() = this } /** * Gets the namespace of this module. */ - string getClosureNamespace() { result = this.getModuleDeclaration().getClosureNamespace() } + string getClosureNamespace() { result = decl.getClosureNamespace() } override Module getAnImportedModule() { result.(ClosureModule).getClosureNamespace() = @@ -156,7 +177,7 @@ module Closure { * Has no result for ES6 modules using `goog.declareModuleId`. */ Variable getExportsVariable() { - this.getModuleDeclaration().getMethodName() = "module" and + decl.getModuleKind() = "goog.module" and result = this.getScope().getVariable("exports") } @@ -185,15 +206,15 @@ module Closure { ClosureScript() { not this instanceof ClosureModule and ( - any(ClosureProvideCall provide).getTopLevel() = this + any(ProvideCallExpr provide).getTopLevel() = this or - any(ClosureRequireCall require).getTopLevel() = this + any(RequireCallExpr require).getTopLevel() = this ) } /** Gets the identifier of a namespace required by this module. */ string getARequiredNamespace() { - exists(ClosureRequireCall require | + exists(RequireCallExpr require | require.getTopLevel() = this and result = require.getClosureNamespace() ) @@ -201,7 +222,7 @@ module Closure { /** Gets the identifer of a namespace provided by this module. */ string getAProvidedNamespace() { - exists(ClosureProvideCall require | + exists(ProvideCallExpr require | require.getTopLevel() = this and result = require.getClosureNamespace() ) @@ -213,7 +234,13 @@ module Closure { */ pragma[noinline] predicate isClosureNamespace(string name) { - exists(string namespace | namespace = any(ClosureNamespaceRef ref).getClosureNamespace() | + exists(string namespace | + namespace = + [ + any(RequireCallExpr ref).getClosureNamespace(), + any(ModuleDeclarationCall c).getClosureNamespace() + ] + | name = namespace.substring(0, namespace.indexOf(".")) or name = namespace diff --git a/javascript/ql/lib/semmle/javascript/ES2015Modules.qll b/javascript/ql/lib/semmle/javascript/ES2015Modules.qll index 379403eb0ee7..e7534449f55b 100644 --- a/javascript/ql/lib/semmle/javascript/ES2015Modules.qll +++ b/javascript/ql/lib/semmle/javascript/ES2015Modules.qll @@ -180,6 +180,9 @@ deprecated private class LiteralImportPath extends PathExpr, ConstantString { * ``` */ class ImportSpecifier extends Expr, @import_specifier { + /** Gets the import declaration in which this specifier appears. */ + ImportDeclaration getImportDeclaration() { result.getASpecifier() = this } + /** Gets the imported symbol; undefined for default and namespace import specifiers. */ Identifier getImported() { result = this.getChildExpr(0) } diff --git a/javascript/ql/lib/semmle/javascript/Expr.qll b/javascript/ql/lib/semmle/javascript/Expr.qll index 8695c893f815..ae02511ba410 100644 --- a/javascript/ql/lib/semmle/javascript/Expr.qll +++ b/javascript/ql/lib/semmle/javascript/Expr.qll @@ -4,6 +4,7 @@ import javascript private import semmle.javascript.internal.CachedStages +private import semmle.javascript.internal.TypeResolution /** * A program element that is either an expression or a type annotation. @@ -170,12 +171,14 @@ class Expr extends @expr, ExprOrStmt, ExprOrType, AST::ValueNode { predicate mayReferToParameter(Parameter p) { DataFlow::parameterNode(p).flowsToExpr(this) } /** + * DEPRECATED. Use `getTypeBinding()` instead. + * * Gets the static type of this expression, as determined by the TypeScript type system. * * Has no result if the expression is in a JavaScript file or in a TypeScript * file that was extracted without type information. */ - Type getType() { ast_node_type(this, result) } + deprecated Type getType() { ast_node_type(this, result) } /** * Holds if the syntactic context that the expression appears in relies on the expression @@ -987,12 +990,14 @@ class InvokeExpr extends @invokeexpr, Expr { } /** + * DEPRECATED. No longer supported. + * * Gets the call signature of the invoked function, as determined by the TypeScript * type system, with overloading resolved and type parameters substituted. * * This predicate is only populated for files extracted with full TypeScript extraction. */ - CallSignatureType getResolvedSignature() { invoke_expr_signature(this, result) } + deprecated CallSignatureType getResolvedSignature() { invoke_expr_signature(this, result) } /** * Gets the index of the targeted call signature among the overload signatures @@ -1003,21 +1008,21 @@ class InvokeExpr extends @invokeexpr, Expr { int getResolvedOverloadIndex() { invoke_expr_overload_index(this, result) } /** + * DEPRECATED. No longer directly supported, but `getResolvedCallee()` may be usable as an alternative. + * * Gets the canonical name of the static call target, as determined by the TypeScript type system. * * This predicate is only populated for files extracted with full TypeScript extraction. */ - CanonicalFunctionName getResolvedCalleeName() { ast_node_symbol(this, result) } + deprecated CanonicalFunctionName getResolvedCalleeName() { ast_node_symbol(this, result) } /** * Gets the statically resolved target function, as determined by the TypeScript type system, if any. * - * This predicate is only populated for files extracted with full TypeScript extraction. - * * Note that the resolved function may be overridden in a subclass and thus is not * necessarily the actual target of this invocation at runtime. */ - Function getResolvedCallee() { result = this.getResolvedCalleeName().getImplementation() } + Function getResolvedCallee() { TypeResolution::callTarget(this, result) } } /** diff --git a/javascript/ql/lib/semmle/javascript/Functions.qll b/javascript/ql/lib/semmle/javascript/Functions.qll index 150dbea3f01b..b72bfbc888e9 100644 --- a/javascript/ql/lib/semmle/javascript/Functions.qll +++ b/javascript/ql/lib/semmle/javascript/Functions.qll @@ -434,12 +434,12 @@ class Function extends @function, Parameterized, TypeParameterized, StmtContaine * * This predicate is only populated for files extracted with full TypeScript extraction. */ - CanonicalFunctionName getCanonicalName() { ast_node_symbol(this, result) } + deprecated CanonicalFunctionName getCanonicalName() { ast_node_symbol(this, result) } /** * Gets the call signature of this function, as determined by the TypeScript compiler, if any. */ - CallSignatureType getCallSignature() { declared_function_signature(this, result) } + deprecated CallSignatureType getCallSignature() { declared_function_signature(this, result) } } /** diff --git a/javascript/ql/lib/semmle/javascript/GlobalAccessPaths.qll b/javascript/ql/lib/semmle/javascript/GlobalAccessPaths.qll index 35ba8cfe601a..4a461961f8af 100644 --- a/javascript/ql/lib/semmle/javascript/GlobalAccessPaths.qll +++ b/javascript/ql/lib/semmle/javascript/GlobalAccessPaths.qll @@ -34,7 +34,7 @@ module AccessPath { not this.accessesGlobal(_) and not this instanceof DataFlow::PropRead and not this instanceof PropertyProjection and - not this instanceof Closure::ClosureNamespaceAccess and + not this.asExpr() instanceof Closure::RequireCallExpr and not this = DataFlow::parameterNode(any(ImmediatelyInvokedFunctionExpr iife).getAParameter()) and not FlowSteps::identityFunctionStep(_, this) } @@ -139,8 +139,8 @@ module AccessPath { result = join(fromReference(prop.getBase(), root), "[number]") ) or - exists(Closure::ClosureNamespaceAccess acc | node = acc | - result = acc.getClosureNamespace() and + exists(Closure::RequireCallExpr req | node = req.flow() | + result = req.getClosureNamespace() and root.isGlobal() ) or diff --git a/javascript/ql/lib/semmle/javascript/JSDoc.qll b/javascript/ql/lib/semmle/javascript/JSDoc.qll index 10970a2e8b04..85b7695cd70e 100644 --- a/javascript/ql/lib/semmle/javascript/JSDoc.qll +++ b/javascript/ql/lib/semmle/javascript/JSDoc.qll @@ -33,6 +33,9 @@ class JSDoc extends @jsdoc, Locatable { result.getTitle() = title } + /** Gets the element to which this JSDoc comment is attached */ + Documentable getDocumentedElement() { result.getDocumentation() = this } + override string toString() { result = this.getComment().toString() } } @@ -299,6 +302,41 @@ class JSDocIdentifierTypeExpr extends @jsdoc_identifier_type_expr, JSDocTypeExpr override predicate isRawFunction() { this.getName() = "Function" } } +private AstNode getAncestorInScope(Documentable doc) { + any(JSDocLocalTypeAccess t).getJSDocComment() = doc.getDocumentation() and // restrict to cases where we need this + result = doc.getParent() + or + exists(AstNode mid | + mid = getAncestorInScope(doc) and + not mid = any(Scope s).getScopeElement() and + result = mid.getParent() + ) +} + +private Scope getScope(Documentable doc) { result.getScopeElement() = getAncestorInScope(doc) } + +pragma[nomagic] +private predicate shouldResolveName(TopLevel top, string name) { + exists(JSDocLocalTypeAccess access | + access.getName() = name and + access.getTopLevel() = top + ) +} + +private LexicalName getOwnLocal(Scope scope, string name, DeclarationSpace space) { + scope = result.getScope() and + name = result.getName() and + space = result.getDeclarationSpace() and + shouldResolveName(scope.getScopeElement().getTopLevel(), name) // restrict size of predicate +} + +private LexicalName resolveLocal(Scope scope, string name, DeclarationSpace space) { + result = getOwnLocal(scope, name, space) + or + result = resolveLocal(scope.getOuterScope(), name, space) and + not exists(getOwnLocal(scope, name, space)) +} + /** * An unqualified identifier in a JSDoc type expression. * @@ -311,6 +349,12 @@ class JSDocIdentifierTypeExpr extends @jsdoc_identifier_type_expr, JSDocTypeExpr */ class JSDocLocalTypeAccess extends JSDocIdentifierTypeExpr { JSDocLocalTypeAccess() { not this = any(JSDocQualifiedTypeAccess a).getNameNode() } + + /** Gets a variable, type-name, or namespace that this expression may resolve to. */ + LexicalName getALexicalName() { + result = + resolveLocal(getScope(this.getJSDocComment().getDocumentedElement()), this.getName(), _) + } } /** @@ -371,7 +415,7 @@ class JSDocNamedTypeExpr extends JSDocTypeExpr { * - `foo.bar.Baz` has prefix `foo` and suffix `.bar.Baz`. * - `Baz` has prefix `Baz` and an empty suffix. */ - predicate hasNameParts(string prefix, string suffix) { + deprecated predicate hasNameParts(string prefix, string suffix) { not this = any(JSDocQualifiedTypeAccess a).getBase() and // restrict size of predicate exists(string regex, string name | regex = "([^.]+)(.*)" | name = this.getRawName() and @@ -379,46 +423,6 @@ class JSDocNamedTypeExpr extends JSDocTypeExpr { suffix = name.regexpCapture(regex, 2) ) } - - pragma[noinline] - pragma[nomagic] - private predicate hasNamePartsAndEnv(string prefix, string suffix, JSDoc::Environment env) { - // Force join ordering - this.hasNameParts(prefix, suffix) and - env.isContainerInScope(this.getContainer()) - } - - /** - * Gets the qualified name of this name by resolving its prefix, if any. - */ - cached - private string resolvedName() { - exists(string prefix, string suffix, JSDoc::Environment env | - this.hasNamePartsAndEnv(prefix, suffix, env) and - result = env.resolveAlias(prefix) + suffix - ) - } - - override predicate hasQualifiedName(string globalName) { - globalName = this.resolvedName() - or - not exists(this.resolvedName()) and - globalName = this.getRawName() - } - - override DataFlow::ClassNode getClass() { - exists(string name | - this.hasQualifiedName(name) and - result.hasQualifiedName(name) - ) - or - // Handle case where a local variable has a reference to the class, - // but the class doesn't have a globally qualified name. - exists(string alias, JSDoc::Environment env | - this.hasNamePartsAndEnv(alias, "", env) and - result.getAClassReference().flowsTo(env.getNodeFromAlias(alias)) - ) - } } /** @@ -447,12 +451,6 @@ class JSDocAppliedTypeExpr extends @jsdoc_applied_type_expr, JSDocTypeExpr { * For example, in `Array`, `string` is the only argument type. */ JSDocTypeExpr getAnArgument() { result = this.getArgument(_) } - - override predicate hasQualifiedName(string globalName) { - this.getHead().hasQualifiedName(globalName) - } - - override DataFlow::ClassNode getClass() { result = this.getHead().getClass() } } /** @@ -472,8 +470,6 @@ class JSDocNullableTypeExpr extends @jsdoc_nullable_type_expr, JSDocTypeExpr { predicate isPrefix() { jsdoc_prefix_qualifier(this) } override JSDocTypeExpr getAnUnderlyingType() { result = this.getTypeExpr().getAnUnderlyingType() } - - override DataFlow::ClassNode getClass() { result = this.getTypeExpr().getClass() } } /** @@ -493,8 +489,6 @@ class JSDocNonNullableTypeExpr extends @jsdoc_non_nullable_type_expr, JSDocTypeE predicate isPrefix() { jsdoc_prefix_qualifier(this) } override JSDocTypeExpr getAnUnderlyingType() { result = this.getTypeExpr().getAnUnderlyingType() } - - override DataFlow::ClassNode getClass() { result = this.getTypeExpr().getClass() } } /** @@ -599,8 +593,6 @@ class JSDocOptionalParameterTypeExpr extends @jsdoc_optional_type_expr, JSDocTyp override JSDocTypeExpr getAnUnderlyingType() { result = this.getUnderlyingType().getAnUnderlyingType() } - - override DataFlow::ClassNode getClass() { result = this.getUnderlyingType().getClass() } } /** @@ -635,7 +627,7 @@ module JSDoc { /** * A statement container which may declare JSDoc name aliases. */ - class Environment extends StmtContainer { + deprecated class Environment extends StmtContainer { /** * Gets the fully qualified name aliased by the given unqualified name * within this container. @@ -685,7 +677,7 @@ module JSDoc { } pragma[noinline] - private predicate isTypenamePrefix(string name) { + deprecated private predicate isTypenamePrefix(string name) { any(JSDocNamedTypeExpr expr).hasNameParts(name, _) } } diff --git a/javascript/ql/lib/semmle/javascript/TypeAnnotations.qll b/javascript/ql/lib/semmle/javascript/TypeAnnotations.qll index d10b60b92b5b..6d0a13c4a38f 100644 --- a/javascript/ql/lib/semmle/javascript/TypeAnnotations.qll +++ b/javascript/ql/lib/semmle/javascript/TypeAnnotations.qll @@ -4,11 +4,22 @@ import javascript private import internal.StmtContainers +private import internal.NameResolution +private import internal.UnderlyingTypes +private import internal.BindingInfo /** * A type annotation, either in the form of a TypeScript type or a JSDoc comment. */ class TypeAnnotation extends @type_annotation, NodeInStmtContainer { + /** + * Gets information about the results of name-resolution for this type. + * + * This can be used to map a type name to the class/interface it refers to, or + * associate it with a named type coming from an dependency. + */ + TypeNameBindingNode getTypeBinding() { result = this } + /** Holds if this is the `any` type. */ predicate isAny() { none() } @@ -75,14 +86,38 @@ class TypeAnnotation extends @type_annotation, NodeInStmtContainer { TypeAnnotation getAnUnderlyingType() { result = this } /** + * DEPRECATED. Use `hasUnderlyingType` instead. + * * Holds if this is a reference to the type with qualified name `globalName` relative to the global scope. */ - predicate hasQualifiedName(string globalName) { none() } + deprecated predicate hasQualifiedName(string globalName) { + UnderlyingTypes::nodeHasUnderlyingType(this, globalName) + } /** + * DEPRECATED. Use `hasUnderlyingType` instead. + * * Holds if this is a reference to the type exported from `moduleName` under the name `exportedName`. */ - predicate hasQualifiedName(string moduleName, string exportedName) { none() } + deprecated predicate hasQualifiedName(string moduleName, string exportedName) { + UnderlyingTypes::nodeHasUnderlyingType(this, moduleName, exportedName) + } + + /** + * Holds if this is a reference to the type with qualified name `globalName` relative to the global scope, + * or is declared as a subtype thereof, or is a union or intersection containing such a type. + */ + final predicate hasUnderlyingType(string globalName) { + UnderlyingTypes::nodeHasUnderlyingType(this, globalName) + } + + /** + * Holds if this is a reference to the type exported from `moduleName` under the name `exportedName`, + * or is declared as a subtype thereof, or is a union or intersection containing such a type. + */ + final predicate hasUnderlyingType(string moduleName, string exportedName) { + UnderlyingTypes::nodeHasUnderlyingType(this, moduleName, exportedName) + } /** Gets the statement in which this type appears. */ Stmt getEnclosingStmt() { none() } @@ -100,12 +135,12 @@ class TypeAnnotation extends @type_annotation, NodeInStmtContainer { * * Note that this has no result for JSDoc type annotations. */ - Type getType() { none() } + deprecated Type getType() { none() } /** * Gets the class referenced by this type annotation, if any. * * This unfolds nullability modifiers and generic type applications. */ - DataFlow::ClassNode getClass() { none() } + final DataFlow::ClassNode getClass() { UnderlyingTypes::nodeHasUnderlyingClassType(this, result) } } diff --git a/javascript/ql/lib/semmle/javascript/TypeScript.qll b/javascript/ql/lib/semmle/javascript/TypeScript.qll index 4be331ed6a50..79b71fcd8c05 100644 --- a/javascript/ql/lib/semmle/javascript/TypeScript.qll +++ b/javascript/ql/lib/semmle/javascript/TypeScript.qll @@ -31,7 +31,7 @@ class NamespaceDefinition extends Stmt, @namespace_definition, AST::ValueNode { /** * Gets the canonical name of the namespace being defined. */ - Namespace getNamespace() { result.getADefinition() = this } + deprecated Namespace getNamespace() { result.getADefinition() = this } } /** @@ -111,12 +111,12 @@ class TypeDefinition extends AstNode, @type_definition { /** * Gets the canonical name of the type being defined. */ - TypeName getTypeName() { result.getADefinition() = this } + deprecated TypeName getTypeName() { result.getADefinition() = this } /** * Gets the type defined by this declaration. */ - Type getType() { ast_node_type(this.getIdentifier(), result) } + deprecated Type getType() { ast_node_type(this.getIdentifier(), result) } override string getAPrimaryQlClass() { result = "TypeDefinition" } } @@ -268,7 +268,7 @@ class TypeAliasDeclaration extends @type_alias_declaration, TypeParameterized, S /** * Gets the canonical name of the type being defined. */ - TypeName getTypeName() { result.getADefinition() = this } + deprecated TypeName getTypeName() { result.getADefinition() = this } override string getAPrimaryQlClass() { result = "TypeAliasDeclaration" } } @@ -548,7 +548,7 @@ class LocalNamespaceName extends @local_namespace_name, LexicalName { /** * Gets the canonical name of the namespace referenced by this name. */ - Namespace getNamespace() { result = this.getADeclaration().getNamespace() } + deprecated Namespace getNamespace() { result = this.getADeclaration().getNamespace() } override DeclarationSpace getDeclarationSpace() { result = "namespace" } } @@ -568,17 +568,13 @@ class TypeExpr extends ExprOrType, @typeexpr, TypeAnnotation { * Has no result if this occurs in a TypeScript file that was extracted * without type information. */ - override Type getType() { ast_node_type(this, result) } + deprecated override Type getType() { ast_node_type(this, result) } override Stmt getEnclosingStmt() { result = ExprOrType.super.getEnclosingStmt() } override Function getEnclosingFunction() { result = ExprOrType.super.getEnclosingFunction() } override TopLevel getTopLevel() { result = ExprOrType.super.getTopLevel() } - - override DataFlow::ClassNode getClass() { - result.getAstNode() = this.getType().(ClassType).getClass() - } } /** @@ -696,60 +692,11 @@ class TypeAccess extends @typeaccess, TypeExpr, TypeRef { /** * Gets the canonical name of the type being accessed. */ - TypeName getTypeName() { ast_node_symbol(this, result) } - - override predicate hasQualifiedName(string globalName) { - this.getTypeName().hasQualifiedName(globalName) - or - exists(LocalTypeAccess local | local = this | - not exists(local.getLocalTypeName()) and // Without a local type name, the type is looked up in the global scope. - globalName = local.getName() - ) - } - - override predicate hasQualifiedName(string moduleName, string exportedName) { - this.getTypeName().hasQualifiedName(moduleName, exportedName) - or - exists(ImportDeclaration imprt, ImportSpecifier spec | - moduleName = getImportName(imprt) and - spec = imprt.getASpecifier() - | - spec.getImportedName() = exportedName and - this = spec.getLocal().(TypeDecl).getLocalTypeName().getAnAccess() - or - (spec instanceof ImportNamespaceSpecifier or spec instanceof ImportDefaultSpecifier) and - this = - spec.getLocal().(LocalNamespaceDecl).getLocalNamespaceName().getAMemberAccess(exportedName) - ) - or - exists(ImportEqualsDeclaration imprt | - moduleName = getImportName(imprt.getImportedEntity()) and - this = - imprt - .getIdentifier() - .(LocalNamespaceDecl) - .getLocalNamespaceName() - .getAMemberAccess(exportedName) - ) - } + deprecated TypeName getTypeName() { ast_node_symbol(this, result) } override string getAPrimaryQlClass() { result = "TypeAccess" } } -/** - * Gets a suitable name for the library imported by `imprt`. - * - * For relative imports, this is the snapshot-relative path to the imported module. - * For non-relative imports, it is the import path itself. - */ -private string getImportName(Import imprt) { - exists(string path | path = imprt.getImportedPathString() | - if path.regexpMatch("[./].*") - then result = imprt.getImportedModule().getFile().getRelativePath() - else result = path - ) -} - /** An identifier that is used as part of a type, such as `Date`. */ class LocalTypeAccess extends @local_type_access, TypeAccess, Identifier, LexicalAccess { override predicate isStringy() { this.getName() = "String" } @@ -822,14 +769,6 @@ class GenericTypeExpr extends @generic_typeexpr, TypeExpr { /** Gets the number of type arguments. This is always at least one. */ int getNumTypeArgument() { result = count(this.getATypeArgument()) } - override predicate hasQualifiedName(string globalName) { - this.getTypeAccess().hasQualifiedName(globalName) - } - - override predicate hasQualifiedName(string moduleName, string exportedName) { - this.getTypeAccess().hasQualifiedName(moduleName, exportedName) - } - override string getAPrimaryQlClass() { result = "GenericTypeExpr" } } @@ -1440,7 +1379,7 @@ class LocalNamespaceDecl extends VarDecl, NamespaceRef { /** * Gets the canonical name of the namespace being defined or aliased by this name. */ - Namespace getNamespace() { ast_node_symbol(this, result) } + deprecated Namespace getNamespace() { ast_node_symbol(this, result) } } /** @@ -1458,7 +1397,7 @@ class NamespaceAccess extends TypeExpr, NamespaceRef, @namespace_access { /** * Gets the canonical name of the namespace being accessed. */ - Namespace getNamespace() { ast_node_symbol(this, result) } + deprecated Namespace getNamespace() { ast_node_symbol(this, result) } override string getAPrimaryQlClass() { result = "NamespaceAccess" } } @@ -1567,7 +1506,7 @@ class EnumDeclaration extends NamespaceDefinition, @enum_declaration, AST::Value /** * Gets the canonical name of the type being defined. */ - TypeName getTypeName() { ast_node_symbol(this, result) } + deprecated TypeName getTypeName() { ast_node_symbol(this, result) } /** * Gets the local namespace name introduced by the enumeration, for use in @@ -1655,7 +1594,7 @@ class EnumMember extends AstNode, @enum_member { /** * Gets the canonical name of the type defined by this enum member. */ - TypeName getTypeName() { ast_node_symbol(this, result) } + deprecated TypeName getTypeName() { ast_node_symbol(this, result) } override string getAPrimaryQlClass() { result = "EnumMember" } } @@ -1830,13 +1769,18 @@ class TypeRootFolder extends Folder { /// Types /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A static type in the TypeScript type system. * * Types are generally not associated with a specific location or AST node. * For instance, there may be many AST nodes representing different uses of the * `number` keyword, but there only exists one `number` type. */ -class Type extends @type { +deprecated class Type extends @type { /** * Gets a string representation of this type. */ @@ -2033,9 +1977,14 @@ class Type extends @type { } /** + * * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A union type or intersection type, such as `string | number` or `T & U`. */ -class UnionOrIntersectionType extends Type, @union_or_intersection_type { +deprecated class UnionOrIntersectionType extends Type, @union_or_intersection_type { /** * Gets the `i`th member of this union or intersection, starting at 0. */ @@ -2053,19 +2002,34 @@ class UnionOrIntersectionType extends Type, @union_or_intersection_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A union type, such as `string | number`. * * Note that the `boolean` type is represented as the union `true | false`, * but is still displayed as `boolean` in string representations. */ -class UnionType extends UnionOrIntersectionType, @union_type { } +deprecated class UnionType extends UnionOrIntersectionType, @union_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * An intersection type, such as `T & {x: number}`. */ -class IntersectionType extends UnionOrIntersectionType, @intersection_type { } +deprecated class IntersectionType extends UnionOrIntersectionType, @intersection_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that describes a JavaScript `Array` object. * * Specifically, the following three kinds of types are considered array types: @@ -2076,7 +2040,7 @@ class IntersectionType extends UnionOrIntersectionType, @intersection_type { } * Foreign array-like objects such as `HTMLCollection` are not normal JavaScript arrays, * and their corresponding types are not considered array types either. */ -class ArrayType extends Type { +deprecated class ArrayType extends Type { ArrayType() { this instanceof @tuple_type or this.(TypeReference).hasQualifiedName("Array") or @@ -2090,25 +2054,40 @@ class ArrayType extends Type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * An array type such as `Array`, or equivalently, `string[]`. */ -class PlainArrayType extends ArrayType, TypeReference { +deprecated class PlainArrayType extends ArrayType, TypeReference { PlainArrayType() { this.hasQualifiedName("Array") } override Type getNumberIndexType() { result = this.getTypeArgument(0) } } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A read-only array type such as `ReadonlyArray`. */ -class ReadonlyArrayType extends ArrayType, TypeReference { +deprecated class ReadonlyArrayType extends ArrayType, TypeReference { ReadonlyArrayType() { this.hasQualifiedName("ReadonlyArray") } } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A tuple type, such as `[number, string]`. */ -class TupleType extends ArrayType, @tuple_type { +deprecated class TupleType extends ArrayType, @tuple_type { /** * Gets the `i`th member of this tuple type, starting at 0. */ @@ -2162,34 +2141,64 @@ class TupleType extends ArrayType, @tuple_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The predefined `any` type. */ -class AnyType extends Type, @any_type { } +deprecated class AnyType extends Type, @any_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The predefined `unknown` type. */ -class UnknownType extends Type, @unknown_type { } +deprecated class UnknownType extends Type, @unknown_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The predefined `string` type. */ -class StringType extends Type, @string_type { } +deprecated class StringType extends Type, @string_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The predefined `number` type. */ -class NumberType extends Type, @number_type { } +deprecated class NumberType extends Type, @number_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The predefined `bigint` type. */ -class BigIntType extends Type, @bigint_type { } +deprecated class BigIntType extends Type, @bigint_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A boolean, number, or string literal type. */ -class LiteralType extends Type, @literal_type { +deprecated class LiteralType extends Type, @literal_type { /** * Gets the string value of this literal. */ @@ -2197,9 +2206,14 @@ class LiteralType extends Type, @literal_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The boolean literal type `true` or `false`. */ -class BooleanLiteralType extends LiteralType, @boolean_literal_type { +deprecated class BooleanLiteralType extends LiteralType, @boolean_literal_type { /** * Gets the boolean value represented by this type. */ @@ -2213,7 +2227,7 @@ class BooleanLiteralType extends LiteralType, @boolean_literal_type { /** * A number literal as a static type. */ -class NumberLiteralType extends LiteralType, @number_literal_type { +deprecated class NumberLiteralType extends LiteralType, @number_literal_type { override string getStringValue() { type_literal_value(this, result) } /** @@ -2228,16 +2242,26 @@ class NumberLiteralType extends LiteralType, @number_literal_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A string literal as a static type. */ -class StringLiteralType extends LiteralType, @string_literal_type { +deprecated class StringLiteralType extends LiteralType, @string_literal_type { override string getStringValue() { type_literal_value(this, result) } } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A bigint literal as a static type. */ -class BigIntLiteralType extends LiteralType { +deprecated class BigIntLiteralType extends LiteralType { override string getStringValue() { type_literal_value(this, result) } /** @@ -2252,9 +2276,14 @@ class BigIntLiteralType extends LiteralType { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `boolean` type, internally represented as the union type `true | false`. */ -class BooleanType extends UnionType { +deprecated class BooleanType extends UnionType { BooleanType() { this.getAnElementType() instanceof @true_type and this.getAnElementType() instanceof @false_type and @@ -2263,9 +2292,14 @@ class BooleanType extends UnionType { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `string` type or a string literal type. */ -class StringLikeType extends Type { +deprecated class StringLikeType extends Type { StringLikeType() { this instanceof StringType or this instanceof StringLiteralType @@ -2273,9 +2307,14 @@ class StringLikeType extends Type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `number` type or a number literal type. */ -class NumberLikeType extends Type { +deprecated class NumberLikeType extends Type { NumberLikeType() { this instanceof NumberType or this instanceof NumberLiteralType @@ -2283,9 +2322,14 @@ class NumberLikeType extends Type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `boolean`, `true,` or `false` type. */ -class BooleanLikeType extends Type { +deprecated class BooleanLikeType extends Type { BooleanLikeType() { this instanceof BooleanType or this instanceof BooleanLiteralType @@ -2293,39 +2337,74 @@ class BooleanLikeType extends Type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `void` type. */ -class VoidType extends Type, @void_type { } +deprecated class VoidType extends Type, @void_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `undefined` type. */ -class UndefinedType extends Type, @undefined_type { } +deprecated class UndefinedType extends Type, @undefined_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `null` type. */ -class NullType extends Type, @null_type { } +deprecated class NullType extends Type, @null_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `never` type. */ -class NeverType extends Type, @never_type { } +deprecated class NeverType extends Type, @never_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `symbol` type or a specific `unique symbol` type. */ -class SymbolType extends Type, @symbol_type { } +deprecated class SymbolType extends Type, @symbol_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `symbol` type. */ -class PlainSymbolType extends SymbolType, @plain_symbol_type { } +deprecated class PlainSymbolType extends SymbolType, @plain_symbol_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A `unique symbol` type. */ -class UniqueSymbolType extends SymbolType, @unique_symbol_type { +deprecated class UniqueSymbolType extends SymbolType, @unique_symbol_type { /** * Gets the canonical name of the variable exposing the symbol. */ @@ -2352,14 +2431,24 @@ class UniqueSymbolType extends SymbolType, @unique_symbol_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The `object` type. */ -class ObjectKeywordType extends Type, @objectkeyword_type { } +deprecated class ObjectKeywordType extends Type, @objectkeyword_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that refers to a class, interface, enum, or enum member. */ -class TypeReference extends Type, @type_reference { +deprecated class TypeReference extends Type, @type_reference { /** * Gets the canonical name of the type being referenced. */ @@ -2410,9 +2499,14 @@ class TypeReference extends Type, @type_reference { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that refers to a class, possibly with type arguments. */ -class ClassType extends TypeReference { +deprecated class ClassType extends TypeReference { ClassDefinition declaration; ClassType() { declaration = this.getADefinition() } @@ -2424,9 +2518,14 @@ class ClassType extends TypeReference { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that refers to an interface, possibly with type arguents. */ -class InterfaceType extends TypeReference { +deprecated class InterfaceType extends TypeReference { InterfaceDeclaration declaration; InterfaceType() { declaration = this.getADefinition() } @@ -2438,9 +2537,14 @@ class InterfaceType extends TypeReference { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that refers to an enum. */ -class EnumType extends TypeReference { +deprecated class EnumType extends TypeReference { EnumDeclaration declaration; EnumType() { declaration = this.getADefinition() } @@ -2452,9 +2556,14 @@ class EnumType extends TypeReference { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that refers to the value of an enum member. */ -class EnumLiteralType extends TypeReference { +deprecated class EnumLiteralType extends TypeReference { EnumMember declaration; EnumLiteralType() { declaration = this.getADefinition() } @@ -2466,9 +2575,14 @@ class EnumLiteralType extends TypeReference { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that refers to a type alias. */ -class TypeAliasReference extends TypeReference { +deprecated class TypeAliasReference extends TypeReference { TypeAliasReference() { type_alias(this, _) } /** @@ -2480,14 +2594,24 @@ class TypeAliasReference extends TypeReference { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * An anonymous interface type, such as `{ x: number }`. */ -class AnonymousInterfaceType extends Type, @object_type { } +deprecated class AnonymousInterfaceType extends Type, @object_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that refers to a type variable. */ -class TypeVariableType extends Type, @typevariable_type { +deprecated class TypeVariableType extends Type, @typevariable_type { /** * Gets a syntactic declaration of this type variable. * @@ -2525,9 +2649,14 @@ class TypeVariableType extends Type, @typevariable_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that refers to a type variable declared on a class, interface or function. */ -class CanonicalTypeVariableType extends TypeVariableType, @canonical_type_variable_type { +deprecated class CanonicalTypeVariableType extends TypeVariableType, @canonical_type_variable_type { override TypeName getHostType() { result = this.getCanonicalName().getParent() } override CanonicalName getCanonicalName() { type_symbol(this, result) } @@ -2536,6 +2665,11 @@ class CanonicalTypeVariableType extends TypeVariableType, @canonical_type_variab } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type that refers to a type variable without a canonical name. * * These arise in generic call signatures such as `(x: T) => T`. @@ -2547,13 +2681,18 @@ class CanonicalTypeVariableType extends TypeVariableType, @canonical_type_variab * - `(x: T) => T` * - `(x: S, y: T) => T`. */ -class LexicalTypeVariableType extends TypeVariableType, @lexical_type_variable_type { +deprecated class LexicalTypeVariableType extends TypeVariableType, @lexical_type_variable_type { override string getName() { types(this, _, result) // The toString value contains the name. } } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A `this` type in a specific class or interface. * * For example, the return type of `span` below is a `this` type @@ -2564,7 +2703,7 @@ class LexicalTypeVariableType extends TypeVariableType, @lexical_type_variable_t * } * ``` */ -class ThisType extends Type, @this_type { +deprecated class ThisType extends Type, @this_type { /** * Gets the type containing the `this` type. */ @@ -2574,10 +2713,15 @@ class ThisType extends Type, @this_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * The type of a named value, `typeof X`, typically denoting the type of * a class constructor, namespace object, enum object, or module object. */ -class TypeofType extends Type, @typeof_type { +deprecated class TypeofType extends Type, @typeof_type { /** * Gets the canonical name of the named value. */ @@ -2650,9 +2794,14 @@ module SignatureKind { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A function or constructor signature in a TypeScript type. */ -class CallSignatureType extends @signature_type { +deprecated class CallSignatureType extends @signature_type { /** * Gets a value indicating if this is a function or constructor signature. */ @@ -2799,14 +2948,25 @@ class CallSignatureType extends @signature_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A function call signature in a type, that is, a signature without the `new` keyword. */ -class FunctionCallSignatureType extends CallSignatureType, @function_signature_type { } +deprecated class FunctionCallSignatureType extends CallSignatureType, @function_signature_type { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A constructor call signature in a type, that is, a signature with the `new` keyword. */ -class ConstructorCallSignatureType extends CallSignatureType, @constructor_signature_type { } +deprecated class ConstructorCallSignatureType extends CallSignatureType, @constructor_signature_type +{ } /** * A type name that defines a promise. @@ -2816,7 +2976,7 @@ class ConstructorCallSignatureType extends CallSignatureType, @constructor_signa * - It has one type parameter, say, `T` * - It has a `then` method whose first argument is a callback that takes a `T` as argument. */ -private class PromiseTypeName extends TypeName { +deprecated private class PromiseTypeName extends TypeName { PromiseTypeName() { // The name must suggest it is a promise. this.getName().matches(["%Promise", "%PromiseLike", "%Thenable", "%Deferred"]) and @@ -2835,12 +2995,17 @@ private class PromiseTypeName extends TypeName { } /** + * DEPRECATED. Static types from the TypeScript compiler are not longer available. Use one of the following alternatives instead: + * - `Expr.getTypeBinding()` + * - `Expr.getNameBinding()` + * - `TypeAnnotation.getTypeBinding()` + * * A type such as `Promise`, describing a promise or promise-like object. * * This includes types whose name and `then` method signature suggest it is a promise, * such as `PromiseLike` and `Thenable`. */ -class PromiseType extends TypeReference { +deprecated class PromiseType extends TypeReference { PromiseType() { this.getNumTypeArgument() = 1 and this.getTypeName() instanceof PromiseTypeName diff --git a/javascript/ql/lib/semmle/javascript/Variables.qll b/javascript/ql/lib/semmle/javascript/Variables.qll index 1eeb735124b5..2f9905f86e17 100644 --- a/javascript/ql/lib/semmle/javascript/Variables.qll +++ b/javascript/ql/lib/semmle/javascript/Variables.qll @@ -27,6 +27,12 @@ class Scope extends @scope { result = this.getAVariable() and result.getName() = name } + + /** Gets the local type name with the given name declared in this scope. */ + LocalTypeName getLocalTypeName(string name) { + result.getScope() = this and + result.getName() = name + } } /** @@ -128,8 +134,26 @@ class Variable extends @variable, LexicalName { /** Gets the scope this variable is declared in. */ override Scope getScope() { variables(this, _, result) } + /** + * Holds if this variable is declared in the top-level of a module using a `declare` statement. + * + * For example: + * ```js + * declare var $: any; + * ``` + * + * Such variables are generally treated as a global variables, except for type-checking related purposes. + */ + pragma[nomagic] + predicate isTopLevelWithAmbientDeclaration() { + this.getScope() instanceof ModuleScope and + forex(VarDecl decl | decl = this.getADeclaration() | decl.isAmbient()) + } + /** Holds if this is a global variable. */ - predicate isGlobal() { this.getScope() instanceof GlobalScope } + predicate isGlobal() { + this.getScope() instanceof GlobalScope or this.isTopLevelWithAmbientDeclaration() + } /** * Holds if this is a variable exported from a TypeScript namespace. diff --git a/javascript/ql/lib/semmle/javascript/ViewComponentInput.qll b/javascript/ql/lib/semmle/javascript/ViewComponentInput.qll index bc80826de5c9..43cd337685db 100644 --- a/javascript/ql/lib/semmle/javascript/ViewComponentInput.qll +++ b/javascript/ql/lib/semmle/javascript/ViewComponentInput.qll @@ -14,34 +14,11 @@ abstract class ViewComponentInput extends DataFlow::Node { private class ViewComponentInputAsThreatModelSource extends ThreatModelSource::Range instanceof ViewComponentInput { - ViewComponentInputAsThreatModelSource() { not isSafeType(this.asExpr().getType()) } + ViewComponentInputAsThreatModelSource() { + not this.asExpr().getTypeBinding().isSanitizingPrimitiveType() + } final override string getThreatModel() { result = "view-component-input" } final override string getSourceType() { result = ViewComponentInput.super.getSourceType() } } - -private predicate isSafeType(Type t) { - t instanceof NumberLikeType - or - t instanceof BooleanLikeType - or - t instanceof UndefinedType - or - t instanceof NullType - or - t instanceof VoidType - or - hasSafeTypes(t, t.(UnionType).getNumElementType()) - or - isSafeType(t.(IntersectionType).getAnElementType()) -} - -/** Hold if the first `n` components of `t` are safe types. */ -private predicate hasSafeTypes(UnionType t, int n) { - isSafeType(t.getElementType(0)) and - n = 1 - or - isSafeType(t.getElementType(n - 1)) and - hasSafeTypes(t, n - 1) -} diff --git a/javascript/ql/lib/semmle/javascript/dataflow/DataFlow.qll b/javascript/ql/lib/semmle/javascript/dataflow/DataFlow.qll index 46801bd1ad7e..df3d0d5ff8ba 100644 --- a/javascript/ql/lib/semmle/javascript/dataflow/DataFlow.qll +++ b/javascript/ql/lib/semmle/javascript/dataflow/DataFlow.qll @@ -27,6 +27,9 @@ private import internal.PreCallGraphStep private import semmle.javascript.internal.CachedStages private import semmle.javascript.dataflow.internal.DataFlowPrivate as Private private import semmle.javascript.dataflow.internal.VariableOrThis +private import semmle.javascript.internal.NameResolution +private import semmle.javascript.internal.UnderlyingTypes +private import semmle.javascript.internal.TypeResolution module DataFlow { /** @@ -189,26 +192,6 @@ module DataFlow { FlowSteps::identityFunctionStep(result, this) } - /** - * Gets the static type of this node as determined by the TypeScript type system. - */ - private Type getType() { - exists(AST::ValueNode node | - this = TValueNode(node) and - ast_node_type(node, result) - ) - or - exists(BindingPattern pattern | - this = lvalueNode(pattern) and - ast_node_type(pattern, result) - ) - or - exists(MethodDefinition def | - this = TThisNode(def.getInit()) and - ast_node_type(def.getDeclaringClass(), result) - ) - } - /** * Gets the type annotation describing the type of this node, * provided that a static type could not be found. @@ -229,6 +212,15 @@ module DataFlow { ) } + private NameResolution::Node getNameResolutionNode() { + this = valueNode(result) + or + exists(PropertyPattern pattern | + result = pattern.getValuePattern() and + this = TPropNode(pattern) + ) + } + /** * Holds if this node is annotated with the given named type, * or is declared as a subtype thereof, or is a union or intersection containing such a type. @@ -236,9 +228,10 @@ module DataFlow { cached predicate hasUnderlyingType(string globalName) { Stages::TypeTracking::ref() and - this.getType().hasUnderlyingType(globalName) - or - this.getFallbackTypeAnnotation().getAnUnderlyingType().hasQualifiedName(globalName) + exists(NameResolution::Node type | + TypeResolution::valueHasType(this.getNameResolutionNode(), type) and + UnderlyingTypes::nodeHasUnderlyingType(type, globalName) + ) } /** @@ -248,9 +241,11 @@ module DataFlow { cached predicate hasUnderlyingType(string moduleName, string typeName) { Stages::TypeTracking::ref() and - this.getType().hasUnderlyingType(moduleName, typeName) - or - this.getFallbackTypeAnnotation().getAnUnderlyingType().hasQualifiedName(moduleName, typeName) + moduleName != "global" and + exists(NameResolution::Node type | + TypeResolution::valueHasType(this.getNameResolutionNode(), type) and + UnderlyingTypes::nodeHasUnderlyingType(type, moduleName, typeName) + ) } /** diff --git a/javascript/ql/lib/semmle/javascript/dataflow/Sources.qll b/javascript/ql/lib/semmle/javascript/dataflow/Sources.qll index 06729815e9a4..f861488a046c 100644 --- a/javascript/ql/lib/semmle/javascript/dataflow/Sources.qll +++ b/javascript/ql/lib/semmle/javascript/dataflow/Sources.qll @@ -333,7 +333,14 @@ module SourceNode { astNode instanceof TaggedTemplateExpr or astNode instanceof Templating::PipeRefExpr or astNode instanceof Templating::TemplateVarRefExpr or - astNode instanceof StringLiteral + astNode instanceof StringLiteral or + astNode instanceof TypeAssertion or + astNode instanceof SatisfiesExpr + ) + or + exists(VariableDeclarator decl | + exists(decl.getTypeAnnotation()) and + this = DataFlow::valueNode(decl.getBindingPattern()) ) or DataFlow::parameterNode(this, _) diff --git a/javascript/ql/lib/semmle/javascript/dataflow/internal/Contents.qll b/javascript/ql/lib/semmle/javascript/dataflow/internal/Contents.qll index 5cf5bf1e48eb..a5af2737c186 100644 --- a/javascript/ql/lib/semmle/javascript/dataflow/internal/Contents.qll +++ b/javascript/ql/lib/semmle/javascript/dataflow/internal/Contents.qll @@ -179,6 +179,9 @@ module Public { /** Holds if this represents values stored at an unknown array index. */ predicate isUnknownArrayElement() { this = MkArrayElementUnknown() } + /** Holds if this represents the value of a resolved promise. */ + predicate isPromiseValue() { this = MkPromiseValue() } + /** Holds if this represents values stored in a `Map` at an unknown key. */ predicate isMapValueWithUnknownKey() { this = MkMapValueWithUnknownKey() } @@ -266,6 +269,11 @@ module Public { or this = ContentSet::anyCapturedContent() and result instanceof Private::MkCapturedContent + or + // Although data flow will never use the special `Awaited` ContentSet in a read or store step, + // it may appear in type-tracking and type resolution, and here it helps to treat is as `Awaited[value]`. + this = MkAwaited() and + result = MkPromiseValue() } /** Gets the singleton content to be accessed. */ diff --git a/javascript/ql/lib/semmle/javascript/frameworks/ClassValidator.qll b/javascript/ql/lib/semmle/javascript/frameworks/ClassValidator.qll index 35f966217bda..8b2ef364054f 100644 --- a/javascript/ql/lib/semmle/javascript/frameworks/ClassValidator.qll +++ b/javascript/ql/lib/semmle/javascript/frameworks/ClassValidator.qll @@ -50,7 +50,7 @@ module ClassValidator { pragma[noinline] private ClassDefinition getClassReferencedByPropRead(DataFlow::PropRead read) { - read.getBase().asExpr().getType().unfold().(ClassType).getClass() = result + read.getBase().asExpr().getTypeBinding().getAnUnderlyingClass().getAstNode() = result } /** diff --git a/javascript/ql/lib/semmle/javascript/frameworks/Electron.qll b/javascript/ql/lib/semmle/javascript/frameworks/Electron.qll index 48b1875a445e..796770b96ee0 100644 --- a/javascript/ql/lib/semmle/javascript/frameworks/Electron.qll +++ b/javascript/ql/lib/semmle/javascript/frameworks/Electron.qll @@ -41,18 +41,19 @@ module Electron { BrowserView() { this = DataFlow::moduleMember("electron", "BrowserView").getAnInstantiation() } } - /** - * An expression of type `BrowserWindow` or `BrowserView`. - */ - private class BrowserObjectByType extends BrowserObject { - BrowserObjectByType() { - exists(string tp | tp = "BrowserWindow" or tp = "BrowserView" | - this.asExpr().getType().hasUnderlyingType("electron", tp) - ) + private class ElectronEntryPoint extends API::EntryPoint { + ElectronEntryPoint() { this = "Electron.Browser" } + + override DataFlow::SourceNode getASource() { + result.hasUnderlyingType(["Electron.BrowserWindow", "Electron.BrowserView"]) } } - private API::Node browserObject() { result.asSource() instanceof NewBrowserObject } + private API::Node browserObject() { + result.asSource() instanceof NewBrowserObject or + result = API::Node::ofType("electron", ["BrowserWindow", "BrowserView"]) or + result = any(ElectronEntryPoint e).getANode() + } /** * A data flow node whose value may originate from a browser object instantiation. diff --git a/javascript/ql/lib/semmle/javascript/frameworks/Express.qll b/javascript/ql/lib/semmle/javascript/frameworks/Express.qll index ffeee7df73ee..6243b2481ef5 100644 --- a/javascript/ql/lib/semmle/javascript/frameworks/Express.qll +++ b/javascript/ql/lib/semmle/javascript/frameworks/Express.qll @@ -48,7 +48,7 @@ module Express { private predicate isRouter(DataFlow::Node e) { isRouter(e, _) or - e.asExpr().getType().hasUnderlyingType("express", "Router") + e.(DataFlow::SourceNode).hasUnderlyingType("express", "Router") or // created by `webpack-dev-server` WebpackDevServer::webpackDevServerApp().flowsTo(e) diff --git a/javascript/ql/lib/semmle/javascript/frameworks/Nest.qll b/javascript/ql/lib/semmle/javascript/frameworks/Nest.qll index dd6e1a7d9159..34fca2d57c98 100644 --- a/javascript/ql/lib/semmle/javascript/frameworks/Nest.qll +++ b/javascript/ql/lib/semmle/javascript/frameworks/Nest.qll @@ -133,7 +133,9 @@ module NestJS { hasSanitizingPipe(this, false) or hasSanitizingPipe(this, true) and - isSanitizingType(this.getParameter().getType().unfold()) + // Note: we could consider types with class-validator decorators to be sanitized here, but instead we consider the root + // object to be tainted, but omit taint steps for the individual properties names that have sanitizing decorators. See ClassValidator.qll. + this.getParameter().getTypeBinding().isSanitizingPrimitiveType() } } @@ -209,19 +211,6 @@ module NestJS { dependsOnType = true } - /** - * Holds if a parameter of type `t` is considered sanitized, provided it has been checked by `ValidationPipe` - * (which relies on metadata emitted by the TypeScript compiler). - */ - private predicate isSanitizingType(Type t) { - t instanceof NumberType - or - t instanceof BooleanType - // - // Note: we could consider types with class-validator decorators to be sanitized here, but instead we consider the root - // object to be tainted, but omit taint steps for the individual properties names that have sanitizing decorators. See ClassValidator.qll. - } - /** * A user-defined pipe class, for example: * ```js @@ -237,7 +226,7 @@ module NestJS { CustomPipeClass() { exists(ClassDefinition cls | this = cls.flow() and - cls.getASuperInterface().hasQualifiedName("@nestjs/common", "PipeTransform") + cls.getASuperInterface().hasUnderlyingType("@nestjs/common", "PipeTransform") ) } @@ -327,14 +316,6 @@ module NestJS { } } - private predicate isStringType(Type type) { - type instanceof StringType - or - type instanceof AnyType - or - isStringType(type.(PromiseType).getElementType().unfold()) - } - /** * A return value from a route handler, seen as an argument to `res.send()`. * @@ -353,10 +334,11 @@ module NestJS { ReturnValueAsResponseSend() { handler.isReturnValueReflected() and this = handler.getAReturn() and - // Only returned strings are sinks - not exists(Type type | - type = this.asExpr().getType() and - not isStringType(type.unfold()) + // Only returned strings are sinks. If we can find a type for the return value, it must be string-like. + ( + this.asExpr().getTypeBinding().hasUnderlyingStringOrAnyType() + or + not exists(this.asExpr().getTypeBinding()) ) } @@ -492,7 +474,7 @@ module NestJS { /** Gets the class being referenced at `node` without relying on the call graph. */ private DataFlow::ClassNode getClassFromNode(DataFlow::Node node) { - result.getAstNode() = node.analyze().getAValue().(AbstractClass).getClass() + result = node.asExpr().getNameBinding().getClassNode() } private predicate providerClassPair( @@ -508,7 +490,7 @@ module NestJS { private class DependencyInjectionStep extends PreCallGraphStep { override predicate classInstanceSource(DataFlow::ClassNode cls, DataFlow::Node node) { exists(DataFlow::ClassNode interfaceClass | - node.asExpr().(Parameter).getType().(ClassType).getClass() = interfaceClass.getAstNode() and + node.asExpr().getTypeBinding().getTypeDefinition() = interfaceClass.getAstNode() and providerClassPair(interfaceClass, cls) ) } diff --git a/javascript/ql/lib/semmle/javascript/frameworks/data/internal/ApiGraphModelsSpecific.qll b/javascript/ql/lib/semmle/javascript/frameworks/data/internal/ApiGraphModelsSpecific.qll index c06490b84368..5e9846e9ad55 100644 --- a/javascript/ql/lib/semmle/javascript/frameworks/data/internal/ApiGraphModelsSpecific.qll +++ b/javascript/ql/lib/semmle/javascript/frameworks/data/internal/ApiGraphModelsSpecific.qll @@ -60,9 +60,7 @@ predicate isPackageUsed(string package) { or package = any(JS::Import imp).getImportedPathString() or - any(JS::TypeName t).hasQualifiedName(package, _) - or - any(JS::TypeAnnotation t).hasQualifiedName(package, _) + any(JS::TypeAnnotation t).hasUnderlyingType(package, _) or exists(JS::PackageJson json | json.getPackageName() = package) } @@ -138,7 +136,7 @@ API::Node getExtraNodeFromType(string type) { parseRelevantTypeString(type, package, qualifiedName) | qualifiedName = "" and - result = [API::moduleImport(package), API::moduleExport(package)] + result = [API::Internal::getAModuleImportRaw(package), API::moduleExport(package)] or // Access instance of a type based on type annotations result = API::Internal::getANodeOfTypeRaw(package, qualifiedName) diff --git a/javascript/ql/lib/semmle/javascript/frameworks/jQuery.qll b/javascript/ql/lib/semmle/javascript/frameworks/jQuery.qll index 4fad4ae1b059..70beadbfa573 100644 --- a/javascript/ql/lib/semmle/javascript/frameworks/jQuery.qll +++ b/javascript/ql/lib/semmle/javascript/frameworks/jQuery.qll @@ -60,11 +60,7 @@ private predicate neverReturnsJQuery(string name) { decl.getBaseName() = "jQuery" and decl.getName() = name | - not decl.getDocumentation() - .getATagByTitle("return") - .getType() - .getAnUnderlyingType() - .hasQualifiedName("jQuery") + not decl.getDocumentation().getATagByTitle("return").getType().hasUnderlyingType("jQuery") ) } @@ -414,6 +410,8 @@ module JQuery { this = DataFlow::moduleImport(["jquery", "zepto", "cash-dom"]) or this.hasUnderlyingType("JQueryStatic") + or + this.hasUnderlyingType("jquery", "") } } } diff --git a/javascript/ql/lib/semmle/javascript/internal/BindingInfo.qll b/javascript/ql/lib/semmle/javascript/internal/BindingInfo.qll new file mode 100644 index 000000000000..9250e3373700 --- /dev/null +++ b/javascript/ql/lib/semmle/javascript/internal/BindingInfo.qll @@ -0,0 +1,177 @@ +/** + * Provides a limited public interface to name/type resolution information. + */ + +private import javascript +private import semmle.javascript.internal.NameResolution +private import semmle.javascript.internal.TypeResolution +private import semmle.javascript.internal.UnderlyingTypes + +/** + * Interface for accessing name-resolution info about type names. + */ +class TypeNameBindingNode extends NameResolution::Node { + /** + * Holds if type refers to, or is an alias for, the given type name relative to the global scope. + * + * For example: + * ```ts + * var x: Document; // hasQualifiedName("Document") + * var x: Electron; // hasQualifiedName("Electron") + * var x: Electron.BrowserWindow; // hasQualifiedName("Electron.BrowserWindow") + * ``` + */ + predicate hasQualifiedName(string qualifiedName) { + NameResolution::nodeRefersToModule(this, "global", qualifiedName) + } + + /** + * Holds if this refers a value exported by the given module, with the given + * qualified name. If the `qualifiedName` is empty, this refers to the module itself. + * + * For example, the type annotations below have the following name bindings: + * ```ts + * import { Request } from "express"; + * + * var x: Request; // hasUnderlyingType("express", "Request") + * var x: Request | null; // no result (see hasUnderlyingType) + * var x: Request & { prop: string }; // no result (see hasUnderlyingType) + * + * interface CustomSubtype extends Request {} + * + * var x: CustomSubtype; // no result (see hasUnderlyingType) + * + * var x: typeof import("express"); // hasUnderlyingType("express", "") + * ``` + */ + predicate hasQualifiedName(string moduleName, string qualifiedName) { + NameResolution::nodeRefersToModule(this, moduleName, qualifiedName) + } + + /** + * Holds if this type refers to the given type exported from the given module, after + * unfolding unions and intersections, and following subtype relations. + * + * For example: + * ```ts + * import { Request } from "express"; + * + * var x: Request; // hasUnderlyingType("express", "Request") + * var x: Request | null; // hasUnderlyingType("express", "Request") + * var x: Request & { prop: string }; // hasUnderlyingType("express", "Request") + * + * interface CustomSubtype extends Request {} + * + * var x: CustomSubtype; // hasUnderlyingType("express", "Request") + * ``` + */ + predicate hasUnderlyingType(string moduleName, string qualifiedName) { + UnderlyingTypes::nodeHasUnderlyingType(this, moduleName, qualifiedName) + } + + /** + * Holds if this type refers to the given type from the global scope, after + * unfolding unions and intersections, and following subtype relations. + * + * For example: + * ```ts + * var x: Document; // hasUnderlyingType("Document") + * var x: Document | null; // hasUnderlyingType("Document") + * var x: Document & { prop: string }; // hasUnderlyingType("Document") + * + * interface CustomSubtype extends Document {} + * + * var x: CustomSubtype; // hasUnderlyingType("Document") + * ``` + */ + predicate hasUnderlyingType(string qualifiedName) { + UnderlyingTypes::nodeHasUnderlyingType(this, qualifiedName) + } + + /** + * Gets the declaration of the type being referenced by this name. + * + * For example: + * ```ts + * class Foo {} + * + * type T = Foo; + * var x: T; // getTypeDefinition() maps T to the class Foo above + * ``` + * + * Note that this has no result for function-style classes referenced from + * a JSDoc comment. + */ + TypeDefinition getTypeDefinition() { TypeResolution::trackType(result) = this } + + /** + * Gets a class that this type refers to, after unfolding unions and intersections (but not subtyping). + * + * For example, the type of `x` maps to the class `C` in each example below: + * ```ts + * class C {} + * + * var x: C; + * var x: C | null; + * var x: C & { prop: string }; + * ``` + */ + DataFlow::ClassNode getAnUnderlyingClass() { + UnderlyingTypes::nodeHasUnderlyingClassType(this, result) + } + + /** + * Holds if this type contains `string` or `any`, possibly wrapped in a promise. + */ + predicate hasUnderlyingStringOrAnyType() { TypeResolution::hasUnderlyingStringOrAnyType(this) } + + /** + * Holds if this refers to a type that is considered untaintable (if actually enforced at runtime). + * + * Specifically, the types `number`, `boolean`, `null`, `undefined`, `void`, `never`, as well as literal types (`"foo"`) + * and enums and enum members have this property. + */ + predicate isSanitizingPrimitiveType() { TypeResolution::isSanitizingPrimitiveType(this) } + + /** + * Holds if the given type is a Promise object. Does not hold for unions unless all parts of the union are promises. + */ + predicate isPromiseType() { TypeResolution::isPromiseType(this) } +} + +/** + * Interface for accessing name-resolution info about expressions. + */ +class ExprNameBindingNode extends NameResolution::Node { + /** + * Holds if this refers a value exported by the given module, with the given + * qualified name. If the `qualifiedName` is empty, this refers to the module itself. + * + * For example, the type annotations below have the following name bindings: + * ```ts + * import * as f from "foo"; + * + * var x = f; // hasQualifiedName(f, "") + * var x = f.x.y; // hasQualifiedName(f, "x.y") + * ``` + */ + predicate hasQualifiedName(string moduleName, string qualifiedName) { + NameResolution::nodeRefersToModule(this, moduleName, qualifiedName) + } + + /** + * Gets the class, or function acting as a class, referenced by this name. + * + * ```ts + * class Foo {} + * const T = Foo; + * var x = T; // getClassNode() maps T to the class Foo above + * + * function Bar() {} + * Bar.prototype.blah = function() {}; + * const S = Bar; + * var x = S; // getClassNode() maps S to the function Bar above + * ``` + */ + DataFlow::ClassNode getClassNode() { NameResolution::nodeRefersToClass(this, result) } +} diff --git a/javascript/ql/lib/semmle/javascript/internal/NameResolution.qll b/javascript/ql/lib/semmle/javascript/internal/NameResolution.qll new file mode 100644 index 000000000000..b25c98fd693b --- /dev/null +++ b/javascript/ql/lib/semmle/javascript/internal/NameResolution.qll @@ -0,0 +1,561 @@ +/** + * Provides name resolution and propagates type information. + */ + +private import javascript + +/** + * Provides name resolution and propagates type information. + */ +module NameResolution { + private class NodeBase = + @expr or @typeexpr or @lexical_name or @toplevel or @function_decl_stmt or @class_decl_stmt or + @namespace_declaration or @enum_declaration or @interface_declaration or + @type_alias_declaration or @jsdoc_type_expr; + + /** + * A node in a graph which we use to perform name and type resolution. + */ + class Node extends NodeBase { + /** Gets a string representation of this node. */ + string toString() { + result = this.(AstNode).toString() + or + result = this.(LexicalName).toString() + or + result = this.(JSDocTypeExpr).toString() + } + + /** Gets the location of this node. */ + Location getLocation() { + result = this.(AstNode).getLocation() + or + result = this.(LocalVariableLike).getLocation() + or + result = this.(JSDocTypeExpr).getLocation() + } + } + + private signature predicate nodeSig(Node node); + + /** + * A module top-level, or a `module {}` or `enum {}` statement. + */ + private class ModuleLike extends AstNode { + ModuleLike() { + this instanceof Module + or + this instanceof NamespaceDefinition // `module {}` or `enum {}` statement + or + // A module wrapped in a promise. We model this as a module exporting the actual module in a property called `$$promise-content`. + this instanceof DynamicImportExpr + } + } + + /** + * A local variable, or a top-level variable that acts as a global variable due to an ambient declaration. + */ + class LocalVariableLike extends Variable { + LocalVariableLike() { this.isLocal() or this.isTopLevelWithAmbientDeclaration() } + + Location getLocation() { + result = + min(Location loc | + loc = this.getADeclaration().getLocation() + | + loc order by loc.getStartLine(), loc.getStartColumn() + ) + } + } + + /** + * Holds if values/namespaces/types in `node1` can flow to values/namespaces/types in `node2`. + * + * May also include some type-specific steps in cases where this is harmless when tracking values. + */ + private predicate commonStep(Node node1, Node node2) { + // Import paths are part of the graph and has an incoming edge from the imported module, if found. + // This ensures we can also use the PathExpr as a source when working with external (unresolved) modules. + exists(Import imprt | + node1 = imprt.getImportedModule() and + node2 = imprt.getImportedPathExpr() + ) + or + exists(ImportNamespaceSpecifier spec | + node1 = spec.getImportDeclaration().getImportedPathExpr() and + node2 = spec.getLocal() + ) + or + exists(ExportNamespaceSpecifier spec | + node1 = spec.getExportDeclaration().(ReExportDeclaration).getImportedPath() and + node2 = spec + ) + or + exists(ExportAssignDeclaration assign | + node1 = assign.getExpression() and + node2 = assign.getContainer() + ) + or + exists(ImportEqualsDeclaration imprt | + node1 = imprt.getImportedEntity() and + node2 = imprt.getIdentifier() + ) + or + exists(ExternalModuleReference ref | + node1 = ref.getImportedPathExpr() and + node2 = ref + ) + or + exists(ImportTypeExpr imprt | + node1 = imprt.getPathExpr() and // TODO: ImportTypeExpr does not seem to be resolved to a Module + node2 = imprt + ) + or + exists(ClassOrInterface cls | + node1 = cls and + node2 = cls.getIdentifier() + ) + or + exists(NamespaceDefinition def | + node1 = def and + node2 = def.getIdentifier() + ) + or + exists(Function fun | + node1 = fun and + node2 = fun.getIdentifier() + ) + or + exists(EnumMember def | + node1 = def.getInitializer() and + node2 = def.getIdentifier() + ) + or + exists(TypeAliasDeclaration alias | + node1 = alias.getDefinition() and + node2 = alias.getIdentifier() + ) + or + exists(VariableDeclarator decl | + node1 = decl.getInit() and + node2 = decl.getBindingPattern() + ) + or + exists(ParenthesizedTypeExpr type | + node1 = type.getElementType() and + node2 = type + ) + or + exists(ParenthesisExpr expr | + node1 = expr.getExpression() and + node2 = expr + ) + or + exists(NonNullAssertion assertion | + // For the time being we don't use this for nullness analysis, so just + // propagate through these assertions. + node1 = assertion.getExpression() and + node2 = assertion + ) + or + exists(FunctionTypeExpr fun | + node1 = fun.getFunction() and + node2 = fun + ) + or + exists(TypeofTypeExpr type | + node1 = type.getExpressionName() and + node2 = type + ) + or + exists(Closure::RequireCallExpr req | + node1.(Closure::ClosureModule).getClosureNamespace() = req.getClosureNamespace() and + node2 = req + ) + or + exists(Closure::ClosureModule mod | + node1 = mod.getExportsVariable() and + node2 = mod + ) + or + exists(ImmediatelyInvokedFunctionExpr fun, int i | + node1 = fun.getArgument(i) and + node2 = fun.getParameter(i) + ) + } + + /** + * Holds if there is a read from `node1` to `node2` that accesses the member `name`. + */ + predicate readStep(Node node1, string name, Node node2) { + exists(QualifiedTypeAccess access | + node1 = access.getQualifier() and + name = access.getIdentifier().getName() and + node2 = access + ) + or + exists(QualifiedNamespaceAccess access | + node1 = access.getQualifier() and + name = access.getIdentifier().getName() and + node2 = access + ) + or + exists(QualifiedVarTypeAccess access | + node1 = access.getQualifier() and + name = access.getIdentifier().getName() and + node2 = access + ) + or + exists(PropAccess access | + node1 = access.getBase() and + name = access.getPropertyName() and + node2 = access + ) + or + exists(ObjectPattern pattern | + node1 = pattern and + node2 = pattern.getPropertyPatternByName(name).getValuePattern() + ) + or + exists(ImportSpecifier spec | + node1 = spec.getImportDeclaration().getImportedPathExpr() and + name = spec.getImportedName() and + node2 = spec.getLocal() + ) + or + exists(SelectiveReExportDeclaration exprt, ExportSpecifier spec | + spec = exprt.getASpecifier() and + node1 = exprt.getImportedPath() and + name = spec.getLocalName() and + node2 = spec.getLocal() + ) + or + exists(JSDocQualifiedTypeAccess expr | + node1 = expr.getBase() and + name = expr.getName() and + node2 = expr + ) + or + exists(AwaitExpr await | + node1 = await.getOperand() and + name = "$$promise-content" and + node2 = await + ) + or + exists(MethodCallExpr call | + call.getMethodName() = "then" and + node1 = call.getReceiver() and + name = "$$promise-content" and + node2 = call.getArgument(0).(Function).getParameter(0) + ) + } + + private signature module TypeResolutionInputSig { + /** + * Holds if flow is permitted through the given variable. + */ + predicate isRelevantVariable(LexicalName var); + } + + /** + * A local variable with exactly one definition, not counting implicit initialization. + */ + private class EffectivelyConstantVariable extends LocalVariableLike { + EffectivelyConstantVariable() { + count(SsaExplicitDefinition ssa | ssa.getSourceVariable() = this) <= 1 // count may be zero if ambient + } + } + + /** Configuration for propagating values and namespaces */ + private module ValueConfig implements TypeResolutionInputSig { + predicate isRelevantVariable(LexicalName var) { + var instanceof EffectivelyConstantVariable + or + // We merge the namespace and value declaration spaces as it seems there is + // no need to distinguish them in practice. + var instanceof LocalNamespaceName + } + } + + /** + * Associates information about values, such as references to a class, module, or namespace. + */ + module ValueFlow = FlowImpl; + + private module TypeConfig implements TypeResolutionInputSig { + predicate isRelevantVariable(LexicalName var) { var instanceof LocalTypeName } + } + + /** + * Associates nodes with information about types. + */ + module TypeFlow = FlowImpl; + + /** + * Generates a directed graph for tracking type names or value names back toward their definition. + * The ultimate definition might not be in the database, but the graph lets us track as far as we can. + * + * The module parameter determines whether types or values should be tracked. + * + * The example below illustrates the need for two separate instantiations of this module. + * When tracking through the nodes corresponding to `X`, we need to remember whether a type or value was tracked. + * + * ```ts + * // lib.ts + * class C1 {} + * class C2 {} + * + * const X = C1; + * type X = C2; + * + * export { X } + * + * // use.ts + * import { X } from "./lib" + * + * var x1 = X // should refer to C1 + * var x2: X; // should refer to C2 + * ``` + */ + private module FlowImpl { + /** + * Gets the exported member of `mod` named `name`. + */ + Node getModuleExport(ModuleLike mod, string name) { + exists(ExportDeclaration exprt | + mod = exprt.getContainer() and + exprt.exportsAs(result, name) and + S::isRelevantVariable(result) + ) + or + exists(ExportNamespaceSpecifier spec | + result = spec and + mod = spec.getContainer() and + name = spec.getExportedName() + ) + or + exists(SelectiveReExportDeclaration exprt, ExportSpecifier spec | + // `export { A as B } from 'blah'` + // This is not covered by `exportsAs` above because neither A or B is a LexicalName + // (both are property names) so it doesn't fit the interface of `exportsAs`. + spec = exprt.getASpecifier() and + mod = exprt.getContainer() and + name = spec.getExportedName() and + result = spec.getLocal() + ) + or + exists(EnumDeclaration enum | + mod = enum and + result = enum.getMemberByName(name).getIdentifier() + ) + or + storeToVariable(result, name, mod.(Closure::ClosureModule).getExportsVariable()) + or + exists(DynamicImportExpr imprt | + mod = imprt and + name = "$$promise-content" and + result = imprt.getImportedPathExpr() + ) + } + + /** + * Holds if `value` is stored in `target.prop`. Only needs to recognise assignments + * that are also recognised by JSDoc tooling such as the Closure compiler. + */ + private predicate storeToVariable(Expr value, string prop, LocalVariableLike target) { + exists(AssignExpr assign | + // target.name = value + assign.getLhs().(PropAccess).accesses(target.getAnAccess(), prop) and + value = assign.getRhs() + ) + or + // target = { name: value } + value = target.getAnAssignedExpr().(ObjectExpr).getPropertyByName(prop).getInit() + } + + /** Steps that only apply for this configuration. */ + private predicate specificStep(Node node1, Node node2) { + exists(LexicalName var | S::isRelevantVariable(var) | + node1.(LexicalDecl).getALexicalName() = var and + node2 = var + or + node1 = var and + node2.(LexicalAccess).getALexicalName() = var + or + node1 = var and + node2.(JSDocLocalTypeAccess).getALexicalName() = var + ) + or + exists(Node base, string name, ModuleLike mod | + readStep(base, name, node2) and + base = trackModule(mod) and + node1 = getModuleExport(mod, name) + ) + } + + /** + * Holds if data should propagate from `node1` to `node2`. + */ + pragma[inline] + predicate step(Node node1, Node node2) { + commonStep(node1, node2) + or + specificStep(node1, node2) + } + + /** Helps track flow from a particular set of source nodes. */ + module Track { + /** Gets the set of nodes reachable from `source`. */ + Node track(Node source) { + isSource(source) and + result = source + or + step(track(source), result) + } + } + + signature class AstNodeSig extends AstNode; + + /** Helps track flow from a particular set of source nodes. */ + module TrackNode { + /** Gets the set of nodes reachable from `source`. */ + Node track(Source source) { + result = source + or + step(track(source), result) + } + } + } + + /** + * Gets a node to which the given module flows. + */ + predicate trackModule = ValueFlow::TrackNode::track/1; + + predicate trackClassValue = ValueFlow::TrackNode::track/1; + + predicate trackFunctionValue = ValueFlow::TrackNode::track/1; + + /** + * Holds if `moduleName` appears to start with a package name, as opposed to a relative file import. + */ + bindingset[moduleName] + private predicate isExternalModuleName(string moduleName) { + not moduleName.regexpMatch("^(\\.|/).*") + } + + bindingset[name] + private string normalizeModuleName(string name) { + result = + name.regexpReplaceAll("^node:", "") + .regexpReplaceAll("\\.[cm]?[jt]sx?$", "") + .regexpReplaceAll("/(index)?$", "") + } + + /** Appends a name onto a qualified name */ + bindingset[a, b] + string append(string a, string b) { + if b = "default" + then result = a + else ( + (if a = "" or b = "" then result = a + b else result = a + "." + b) and + result.length() < 100 + ) + } + + private predicate needsQualifiedName(Node node) { + node = any(JSDocLocalTypeAccess t).getALexicalName().(Variable) + or + exists(Node prev | needsQualifiedName(prev) | + ValueFlow::step(node, prev) + or + readStep(node, _, prev) + ) + } + + /** + * Holds if `node` is a reference to the given module, or a qualified name rooted in that module. + * + * If `qualifiedName` is empty, `node` refers to the module itself. + * + * If `mod` is the string `"global"`, `node` refers to a global access path. + * + * Unlike `trackModule`, this is intended to track uses of external packages. + */ + predicate nodeRefersToModule(Node node, string mod, string qualifiedName) { + exists(Expr path | + path = any(Import imprt).getImportedPathExpr() or + path = any(ReExportDeclaration e).getImportedPath() + | + node = path and + mod = normalizeModuleName(path.getStringValue()) and + isExternalModuleName(mod) and + qualifiedName = "" + ) + or + mod = "global" and + exists(LocalNamespaceAccess access | + node = access and + not exists(access.getLocalNamespaceName()) and + access.getName() = qualifiedName + ) + or + mod = "global" and + exists(JSDocLocalTypeAccess access | + node = access and + not exists(access.getALexicalName()) and + access.getName() = qualifiedName + ) + or + mod = "global" and + exists(GlobalVarAccess access | + node = access and + needsQualifiedName(access) and // restrict number of qualified names we generate + access.getName() = qualifiedName + ) + or + mod = "global" and + qualifiedName = node.(Closure::RequireCallExpr).getClosureNamespace() + or + // Additionally track through bulk re-exports (`export * from 'mod`). + // These are normally handled by 'exportAs' which supports various shadowing rules, + // but has no effect when the ultimate re-exported module is not resolved to a Module. + // We propagate external module refs through bulk re-exports and ignore shadowing rules. + exists(BulkReExportDeclaration reExport | + nodeRefersToModule(reExport.getImportedPath(), mod, qualifiedName) and + node = reExport.getContainer() + ) + or + exists(Node mid | + nodeRefersToModule(mid, mod, qualifiedName) and + ValueFlow::step(mid, node) + ) + or + exists(Node mid, string prefix, string step | + nodeRefersToModule(mid, mod, prefix) and + readStep(mid, step, node) and + qualifiedName = append(prefix, step) + ) + } + + pragma[nomagic] + predicate classHasGlobalName(DataFlow::ClassNode cls, string name) { + cls.flowsTo(AccessPath::getAnAssignmentTo(name)) and + not cls.getTopLevel().isExterns() // don't propagate externs classes + } + + /** + * Holds if `node` refers to the given class. + */ + pragma[nomagic] + predicate nodeRefersToClass(Node node, DataFlow::ClassNode cls) { + exists(string name | + classHasGlobalName(cls, name) and + nodeRefersToModule(node, "global", name) + ) + or + trackClassValue(cls.getAstNode()) = node + or + trackFunctionValue(cls.getAstNode()) = node + } +} diff --git a/javascript/ql/lib/semmle/javascript/internal/TypeResolution.qll b/javascript/ql/lib/semmle/javascript/internal/TypeResolution.qll new file mode 100644 index 000000000000..9829651621e4 --- /dev/null +++ b/javascript/ql/lib/semmle/javascript/internal/TypeResolution.qll @@ -0,0 +1,418 @@ +private import javascript +private import semmle.javascript.internal.NameResolution::NameResolution +private import semmle.javascript.internal.UnderlyingTypes +private import semmle.javascript.dataflow.internal.sharedlib.SummaryTypeTracker as SummaryTypeTracker + +module TypeResolution { + predicate trackType = TypeFlow::TrackNode::track/1; + + /** + * Gets a node that has `fun` as an underlying type. + * + * We track through underlying types as an approximate way to handle calls to a type + * that is a union/intersection involving functions. + */ + Node trackUnderlyingFunctionType(Function fun) { + result = fun + or + exists(Node mid | mid = trackUnderlyingFunctionType(fun) | + TypeFlow::step(mid, result) + or + UnderlyingTypes::underlyingTypeStep(mid, result) + ) + } + + /** + * Gets the representative for the type containing the given member. + * + * For non-static members this is simply the enclosing type declaration. + * + * For static members we use the class's `Variable` as representative for the type of the class object. + */ + private Node getMemberBase(MemberDeclaration member) { + if member.isStatic() + then result = member.getDeclaringClass().getVariable() + else result = member.getDeclaringType() + } + + /** + * Holds if `host` is a type with a `content` of type `memberType`, not counting inherited members. + */ + private predicate typeOwnMember(Node host, DataFlow::Content content, Node memberType) { + exists(MemberDeclaration decl | host = getMemberBase(decl) | + exists(FieldDeclaration field | + decl = field and + content.asPropertyName() = field.getName() and + memberType = field.getTypeAnnotation() + ) + or + exists(MethodDeclaration method | + decl = method and + content.asPropertyName() = method.getName() + | + not method instanceof AccessorMethodDeclaration and + memberType = method.getBody() // use the Function as representative for the function type + or + method instanceof GetterMethodDeclaration and + memberType = method.getBody().getReturnTypeAnnotation() + ) + or + decl instanceof IndexSignature and + memberType = decl.(IndexSignature).getBody().getReturnTypeAnnotation() and + content.isUnknownArrayElement() + ) + or + // Ad-hoc support for array types. We don't support generics in general currently, we just special-case arrays and promises. + content.isUnknownArrayElement() and + ( + memberType = host.(ArrayTypeExpr).getElementType() + or + exists(GenericTypeExpr type | + host = type and + type.getTypeAccess().(LocalTypeAccess).getName() = ["Array", "ReadonlyArray"] and + memberType = type.getTypeArgument(0) + ) + or + exists(JSDocAppliedTypeExpr type | + host = type and + type.getHead().(JSDocLocalTypeAccess).getName() = "Array" and + memberType = type.getArgument(0) + ) + ) + or + content.isPromiseValue() and + memberType = unwrapPromiseType(host) + } + + /** + * Holds if `host` is a type with a `content` of type `memberType`, possible due to inheritance. + */ + private predicate typeMember(Node host, DataFlow::Content content, Node memberType) { + typeOwnMember(host, content, memberType) + or + // Inherit members from base types + not typeOwnMember(host, content, _) and + exists(ClassOrInterface baseType | typeMember(baseType, content, memberType) | + host.(ClassDefinition).getSuperClass() = trackClassValue(baseType) + or + host.(ClassOrInterface).getASuperInterface() = trackType(baseType) + ) + } + + /** + * Holds `use` refers to `host`, and `host` has type members. + * + * Currently steps through unions and intersections, which acts as a basic + * approximation to the unions/intersection of objects. + */ + private predicate typeMemberHostReaches(Node host, Node use) { + typeMember(host, _, _) and + use = host + or + exists(Node mid | typeMemberHostReaches(host, mid) | + TypeFlow::step(mid, use) + or + UnderlyingTypes::underlyingTypeStep(mid, use) + ) + } + + /** + * Holds if there is a read from from `object` to `member` that reads `contents`. + */ + private predicate valueReadStep(Node object, DataFlow::ContentSet contents, Node member) { + member.(PropAccess).accesses(object, contents.asPropertyName()) + or + object.(ObjectPattern).getPropertyPatternByName(contents.asPropertyName()).getValuePattern() = + member + or + member.(AwaitExpr).getOperand() = object and + contents = DataFlow::ContentSet::promiseValue() + or + SummaryTypeTracker::basicLoadStep(object.(AST::ValueNode).flow(), + member.(AST::ValueNode).flow(), contents) + } + + predicate callTarget(InvokeExpr call, Function target) { + exists(ClassDefinition cls | + valueHasType(call.(NewExpr).getCallee(), trackClassValue(cls)) and + target = cls.getConstructor().getBody() + ) + or + valueHasType(call.getCallee(), trackFunctionValue(target)) + or + valueHasType(call.getCallee(), trackUnderlyingFunctionType(target)) and + ( + call instanceof NewExpr and + target = any(ConstructorTypeExpr t).getFunction() + or + call instanceof CallExpr and + target = any(PlainFunctionTypeExpr t).getFunction() + ) + or + exists(InterfaceDefinition interface, CallSignature sig | + valueHasType(call.getCallee(), trackType(interface)) and + sig = interface.getACallSignature() and + target = sig.getBody() + | + call instanceof NewExpr and + sig instanceof ConstructorCallSignature + or + call instanceof CallExpr and + sig instanceof FunctionCallSignature + ) + } + + private predicate functionReturnType(Function func, Node returnType) { + returnType = func.getReturnTypeAnnotation() + or + not exists(func.getReturnTypeAnnotation()) and + exists(Function functionType | + contextualType(func, trackUnderlyingFunctionType(functionType)) and + returnType = functionType.getReturnTypeAnnotation() + ) + } + + bindingset[name] + private predicate isPromiseTypeName(string name) { + name.regexpMatch(".?(Promise|Thenable)(Like)?") + } + + private Node unwrapPromiseType(Node promiseType) { + exists(GenericTypeExpr type | + promiseType = type and + isPromiseTypeName(type.getTypeAccess().(LocalTypeAccess).getName()) and + result = type.getTypeArgument(0) + ) + or + exists(JSDocAppliedTypeExpr type | + promiseType = type and + isPromiseTypeName(type.getHead().(JSDocLocalTypeAccess).getName()) and + result = type.getArgument(0) + ) + } + + predicate contextualType(Node value, Node type) { + exists(LocalVariableLike v | + type = v.getADeclaration().getTypeAnnotation() and + value = v.getAnAssignedExpr() + ) + or + exists(InvokeExpr call, Function target, int i | + callTarget(call, target) and + value = call.getArgument(i) and + type = target.getParameter(i).getTypeAnnotation() + ) + or + exists(Function lambda, Node returnType | + value = lambda.getAReturnedExpr() and + functionReturnType(lambda, returnType) + | + not lambda.isAsyncOrGenerator() and + type = returnType + or + lambda.isAsync() and + type = unwrapPromiseType(returnType) + ) + or + exists(ObjectExpr object, Node objectType, Node host, string name | + contextualType(object, objectType) and + typeMemberHostReaches(host, objectType) and + typeMember(host, any(DataFlow::Content c | c.asPropertyName() = name), type) and + value = object.getPropertyByName(name).getInit() + ) + or + exists(ArrayExpr array, Node arrayType, Node host | + contextualType(array, arrayType) and + typeMemberHostReaches(host, arrayType) and + typeMember(host, any(DataFlow::Content c | c.isUnknownArrayElement()), type) and + value = array.getAnElement() + ) + } + + /** + * Holds if `value` has the given `type`. + */ + predicate valueHasType(Node value, Node type) { + value.(BindingPattern).getTypeAnnotation() = type + or + value.(TypeAssertion).getTypeAnnotation() = type + or + value.(SatisfiesExpr).getTypeAnnotation() = type + or + exists(VarDecl decl | + // ValueFlow::step is restricted to variables with at most one assignment. Allow the type annotation + // of a variable to propagate to its uses, even if the variable has multiple assignments. + type = decl.getTypeAnnotation() and + value = decl.getVariable().(LocalVariableLike).getAnAccess() + ) + or + exists(MemberDeclaration member | + value.(ThisExpr).getBindingContainer() = member.getInit() and + type = getMemberBase(member) + ) + or + exists(ClassDefinition cls | + value = cls and + type = cls.getVariable() + ) + or + exists(FunctionDeclStmt fun | + value = fun and + type = fun.getVariable() + ) + or + exists(Function target | callTarget(value, target) | + type = target.getReturnTypeAnnotation() + or + exists(ClassDefinition cls | + target = cls.getConstructor().getBody() and + type = cls + ) + ) + or + // Contextual typing for parameters + exists(Function lambda, Function functionType, int i | + contextualType(lambda, trackUnderlyingFunctionType(functionType)) + or + exists(InterfaceDefinition interface | + contextualType(lambda, trackType(interface)) and + functionType = interface.getACallSignature().getBody() + ) + | + value = lambda.getParameter(i) and + not exists(value.(Parameter).getTypeAnnotation()) and + type = functionType.getParameter(i).getTypeAnnotation() + ) + or + exists(Node mid | valueHasType(mid, type) | ValueFlow::step(mid, value)) + or + exists(Node mid, Node midType, DataFlow::ContentSet contents, Node host | + valueReadStep(mid, contents, value) and + valueHasType(mid, midType) and + typeMemberHostReaches(host, midType) and + typeMember(host, contents.getAReadContent(), type) + ) + } + + signature predicate nodeSig(Node node); + + /** + * Tracks types that have a certain property, in the sense that: + * - an intersection type has the property if any member has the property + * - a union type has the property if all its members have the property + */ + module TrackMustProp { + predicate hasProperty(Node node) { + directlyHasProperty(node) + or + exists(Node mid | + hasProperty(mid) and + TypeFlow::step(mid, node) + ) + or + unionHasProp(node) + or + hasProperty(node.(IntersectionTypeExpr).getAnElementType()) + or + exists(ConditionalTypeExpr cond | + node = cond and + hasProperty(cond.getTrueType()) and + hasProperty(cond.getFalseType()) + ) + } + + private predicate unionHasProp(UnionTypeExpr node, int n) { + hasProperty(node.getElementType(0)) and n = 1 + or + unionHasProp(node, n - 1) and + hasProperty(node.getElementType(n - 1)) + } + + private predicate unionHasProp(UnionTypeExpr node) { + unionHasProp(node, node.getNumElementType()) + } + } + + module ValueHasProperty { + predicate valueHasProperty(Node value) { + exists(Node type | + valueHasType(value, type) and + typeHasProperty(type) + ) + } + } + + private predicate isSanitizingPrimitiveTypeBase(Node node) { + node.(TypeExpr).isNumbery() + or + node.(TypeExpr).isBooleany() + or + node.(TypeExpr).isNull() + or + node.(TypeExpr).isUndefined() + or + node.(TypeExpr).isVoid() + or + node.(TypeExpr).isNever() + or + node.(TypeExpr).isBigInt() + or + node.(TypeExpr).isSymbol() + or + node instanceof LiteralTypeExpr + or + node = any(EnumMember m).getIdentifier() // enum members are constant + or + node instanceof EnumDeclaration // enums are unions of constants + } + + /** + * Holds if `node` refers to a type that is considered untaintable (if actually enforced at runtime). + * + * Specifically, the types `number`, `boolean`, `null`, `undefined`, `void`, `never`, as well as literal types (`"foo"`) + * and enums and enum members have this property. + */ + predicate isSanitizingPrimitiveType = + TrackMustProp::hasProperty/1; + + /** + * Holds if `value` has a type that is considered untaintable (if actually enforced at runtime). + * + * See `isSanitizingPrimitiveType`. + */ + predicate valueHasSanitizingPrimitiveType = + ValueHasProperty::valueHasProperty/1; + + private predicate isPromiseBase(Node node) { exists(unwrapPromiseType(node)) } + + /** + * Holds if the given type is a Promise object. Does not hold for unions unless all parts of the union are promises. + */ + predicate isPromiseType = TrackMustProp::hasProperty/1; + + /** + * Holds if the given value has a type that implied it is a Promise object. Does not hold for unions unless all parts of the union are promises. + */ + predicate valueHasPromiseType = ValueHasProperty::valueHasProperty/1; + + /** + * Holds if `type` contains `string` or `any`, possibly wrapped in a promise. + */ + predicate hasUnderlyingStringOrAnyType(Node type) { + type.(TypeAnnotation).isStringy() + or + type.(TypeAnnotation).isAny() + or + type instanceof StringLiteralTypeExpr + or + type instanceof TemplateLiteralTypeExpr + or + exists(Node mid | hasUnderlyingStringOrAnyType(mid) | + TypeFlow::step(mid, type) + or + UnderlyingTypes::underlyingTypeStep(mid, type) + or + type = unwrapPromiseType(mid) + ) + } +} diff --git a/javascript/ql/lib/semmle/javascript/internal/UnderlyingTypes.qll b/javascript/ql/lib/semmle/javascript/internal/UnderlyingTypes.qll new file mode 100644 index 000000000000..5461cb3d50f2 --- /dev/null +++ b/javascript/ql/lib/semmle/javascript/internal/UnderlyingTypes.qll @@ -0,0 +1,122 @@ +/** + * Provides name resolution and propagates type information. + */ + +private import javascript +private import semmle.javascript.internal.NameResolution::NameResolution + +/** + * Provides name resolution and propagates type information. + */ +module UnderlyingTypes { + private predicate subtypeStep(Node node1, Node node2) { + exists(ClassOrInterface cls | + ( + node1 = cls.getSuperClass() or + node1 = cls.getASuperInterface() + ) and + node2 = cls + ) + } + + predicate underlyingTypeStep(Node node1, Node node2) { + exists(UnionOrIntersectionTypeExpr type | + node1 = type.getAnElementType() and + node2 = type + ) + or + exists(ReadonlyTypeExpr type | + node1 = type.getElementType() and + node2 = type + ) + or + exists(OptionalTypeExpr type | + node1 = type.getElementType() and + node2 = type + ) + or + exists(GenericTypeExpr type | + node1 = type.getTypeAccess() and + node2 = type + ) + or + exists(ExpressionWithTypeArguments e | + node1 = e.getExpression() and + node2 = e + ) + or + exists(JSDocUnionTypeExpr type | + node1 = type.getAnAlternative() and + node2 = type + ) + or + exists(JSDocNonNullableTypeExpr type | + node1 = type.getTypeExpr() and + node2 = type + ) + or + exists(JSDocNullableTypeExpr type | + node1 = type.getTypeExpr() and + node2 = type + ) + or + exists(JSDocAppliedTypeExpr type | + node1 = type.getHead() and + node2 = type + ) + or + exists(JSDocOptionalParameterTypeExpr type | + node1 = type.getUnderlyingType() and + node2 = type + ) + } + + predicate nodeHasUnderlyingType(Node node, string mod, string name) { + nodeRefersToModule(node, mod, name) + or + exists(JSDocLocalTypeAccess type | + node = type and + not exists(type.getALexicalName()) and + not type = any(JSDocQualifiedTypeAccess t).getBase() and + name = type.getName() and + mod = "global" + ) + or + exists(LocalTypeAccess type | + node = type and + not exists(type.getLocalTypeName()) and + name = type.getName() and + mod = "global" + ) + or + exists(Node mid | nodeHasUnderlyingType(mid, mod, name) | + TypeFlow::step(mid, node) + or + underlyingTypeStep(mid, node) + or + subtypeStep(mid, node) + ) + } + + pragma[nomagic] + predicate nodeHasUnderlyingType(Node node, string name) { + nodeHasUnderlyingType(node, "global", name) + } + + predicate nodeHasUnderlyingClassType(Node node, DataFlow::ClassNode cls) { + node = cls.getAstNode() + or + exists(string name | + classHasGlobalName(cls, name) and + nodeHasUnderlyingType(node, name) + ) + or + exists(Node mid | nodeHasUnderlyingClassType(mid, cls) | + TypeFlow::step(mid, node) + or + underlyingTypeStep(mid, node) + // Note: unlike for external types, we do not use subtype steps here. + // The caller is responsible for handling the class hierarchy. + ) + } +} diff --git a/javascript/ql/src/Declarations/UnreachableMethodOverloads.ql b/javascript/ql/src/Declarations/UnreachableMethodOverloads.ql index 23406eb0b72a..9e9da7201499 100644 --- a/javascript/ql/src/Declarations/UnreachableMethodOverloads.ql +++ b/javascript/ql/src/Declarations/UnreachableMethodOverloads.ql @@ -43,20 +43,22 @@ string getKind(MemberDeclaration m) { /** * A call-signature that originates from a MethodSignature in the AST. */ -private class MethodCallSig extends CallSignatureType { - string name; - - MethodCallSig() { - exists(MethodSignature sig | - this = sig.getBody().getCallSignature() and - name = sig.getName() - ) +private class MethodCallSig extends Function { + private MethodSignature signature; + + MethodCallSig() { this = signature.getBody() } + + int getNumOptionalParameter() { + result = count(Parameter p | p = this.getParameter(_) and p.isDeclaredOptional()) + } + + int getNumRequiredParameter() { + result = count(Parameter p | p = this.getParameter(_) and not p.isDeclaredOptional()) } - /** - * Gets the name of any member that has this signature. - */ - string getName() { result = name } + SignatureKind getKind() { result = SignatureKind::function() } + + TypeExpr getTypeParameterBound(int i) { result = this.getTypeParameter(i).getBound() } } pragma[noinline] @@ -73,6 +75,7 @@ private MethodCallSig getMethodCallSigWithFingerprint( /** * Holds if the two call signatures could be overloads of each other and have the same parameter types. */ +pragma[inline] predicate matchingCallSignature(MethodCallSig method, MethodCallSig other) { other = getMethodCallSigWithFingerprint(method.getName(), method.getNumOptionalParameter(), @@ -107,6 +110,16 @@ private MethodSignature getMethodSignatureWithFingerprint( result.getBody().getNumParameter() = numParameters } +bindingset[t1, t2] +pragma[inline_late] +private predicate sameType(TypeExpr t1, TypeExpr t2) { + t1.(PredefinedTypeExpr).getName() = t2.(PredefinedTypeExpr).getName() + or + t1 instanceof ThisTypeExpr and t2 instanceof ThisTypeExpr + or + t1.(LocalTypeAccess).getLocalTypeName() = t2.(LocalTypeAccess).getLocalTypeName() +} + /** * Holds if the two method signatures are overloads of each other and have the same parameter types. */ @@ -120,14 +133,13 @@ predicate signaturesMatch(MethodSignature method, MethodSignature other) { not exists(method.getBody().getThisTypeAnnotation()) and not exists(other.getBody().getThisTypeAnnotation()) or - method.getBody().getThisTypeAnnotation().getType() = - other.getBody().getThisTypeAnnotation().getType() + sameType(method.getBody().getThisTypeAnnotation(), other.getBody().getThisTypeAnnotation()) ) and // The types are compared in matchingCallSignature. This is a consistency check that the textual representation of the type-annotations are somewhat similar. forall(int i | i in [0 .. -1 + method.getBody().getNumParameter()] | getParameterTypeAnnotation(method, i) = getParameterTypeAnnotation(other, i) ) and - matchingCallSignature(method.getBody().getCallSignature(), other.getBody().getCallSignature()) + matchingCallSignature(method.getBody(), other.getBody()) } from ClassOrInterface decl, string name, MethodSignature previous, MethodSignature unreachable diff --git a/javascript/ql/src/Expressions/MissingAwait.ql b/javascript/ql/src/Expressions/MissingAwait.ql index d97c006a7bd1..4299f5f14470 100644 --- a/javascript/ql/src/Expressions/MissingAwait.ql +++ b/javascript/ql/src/Expressions/MissingAwait.ql @@ -28,7 +28,7 @@ predicate isPromise(DataFlow::SourceNode node, boolean nullable) { isAsyncCall(node, nullable) or not isAsyncCall(node, _) and - node.asExpr().getType() instanceof PromiseType and + node.asExpr().getTypeBinding().isPromiseType() and nullable = true } diff --git a/javascript/ql/src/meta/alerts/CallGraph.ql b/javascript/ql/src/meta/alerts/CallGraph.ql index 364d81e32c90..c721e72f6404 100644 --- a/javascript/ql/src/meta/alerts/CallGraph.ql +++ b/javascript/ql/src/meta/alerts/CallGraph.ql @@ -12,7 +12,10 @@ import javascript from DataFlow::Node invoke, Function f, string kind where - invoke.(DataFlow::InvokeNode).getACallee() = f and kind = "Call" - or - invoke.(DataFlow::PropRef).getAnAccessorCallee().getFunction() = f and kind = "Accessor call" + ( + invoke.(DataFlow::InvokeNode).getACallee() = f and kind = "Call" + or + invoke.(DataFlow::PropRef).getAnAccessorCallee().getFunction() = f and kind = "Accessor call" + ) and + not f.getTopLevel().isExterns() select invoke, kind + " to $@", f, f.describe() diff --git a/javascript/ql/src/meta/types/TypedExprs.ql b/javascript/ql/src/meta/types/TypedExprs.ql deleted file mode 100644 index 5e9efc349dc6..000000000000 --- a/javascript/ql/src/meta/types/TypedExprs.ql +++ /dev/null @@ -1,17 +0,0 @@ -/** - * @name Typed expressions - * @description The number of expressions for which the TypeScript extractor could - * extract a type other than 'any'. - * @kind metric - * @metricType project - * @metricAggregate sum - * @tags meta - * @id js/meta/typed-expressions - */ - -import javascript -import meta.MetaMetrics - -predicate isProperType(Type t) { not t instanceof AnyType } - -select projectRoot(), count(Expr e | isProperType(e.getType())) diff --git a/javascript/ql/src/meta/types/TypesWithQualifiedName.ql b/javascript/ql/src/meta/types/TypesWithQualifiedName.ql deleted file mode 100644 index db23d2a807ef..000000000000 --- a/javascript/ql/src/meta/types/TypesWithQualifiedName.ql +++ /dev/null @@ -1,14 +0,0 @@ -/** - * @name Types with qualified name - * @description The number of type annotations with a qualified name - * @kind metric - * @metricType project - * @metricAggregate sum - * @tags meta - * @id js/meta/types-with-qualified-name - */ - -import javascript -import meta.MetaMetrics - -select projectRoot(), count(TypeAnnotation t | t.hasQualifiedName(_) or t.hasQualifiedName(_, _)) diff --git a/javascript/ql/test/library-tests/CallGraphs/AnnotatedTest/types.ts b/javascript/ql/test/library-tests/CallGraphs/AnnotatedTest/types.ts new file mode 100644 index 000000000000..6dd94bcf1952 --- /dev/null +++ b/javascript/ql/test/library-tests/CallGraphs/AnnotatedTest/types.ts @@ -0,0 +1,27 @@ +namespace NS { + export class C { + /** name:NS.C.m */ + m() { } + } + + export class D extends C { } +} + +function t1(c: NS.C, d: NS.D) { + /** calls:NS.C.m */ + c.m(); + + /** calls:NS.C.m */ + d.m(); +} + +async function t2(cp: Promise) { + const c = await cp; + /** calls:NS.C.m */ + c.m(); + + cp.then(c2 => { + /** calls:NS.C.m */ + c2.m(); + }) +} diff --git a/javascript/ql/test/library-tests/DataFlow/tests.expected b/javascript/ql/test/library-tests/DataFlow/tests.expected index 55c6771eef02..26ba8c46a993 100644 --- a/javascript/ql/test/library-tests/DataFlow/tests.expected +++ b/javascript/ql/test/library-tests/DataFlow/tests.expected @@ -1514,6 +1514,7 @@ sources | tst2.ts:7:1:9:1 | return of function setX | | tst2.ts:8:3:8:5 | A.x | | tst2.ts:11:11:11:13 | A.x | +| tst2.ts:11:11:11:23 | A.x as number | | tst2.ts:13:1:13:40 | class S ... ing> {} | | tst2.ts:13:26:13:29 | List | | tst2.ts:13:39:13:38 | (...arg ... rgs); } | @@ -1522,6 +1523,7 @@ sources | tst2.ts:13:39:13:38 | super(...args) | | tst2.ts:13:39:13:38 | this | | tst2.ts:15:11:15:13 | A.x | +| tst2.ts:15:11:15:30 | A.x satisfies number | | tst.js:1:1:1:0 | this | | tst.js:1:1:1:24 | import ... m 'fs'; | | tst.js:1:10:1:11 | fs | diff --git a/javascript/ql/test/library-tests/JSDoc/NameResolution/test.expected b/javascript/ql/test/library-tests/JSDoc/NameResolution/test.expected index 97730513195b..7c015994aafe 100644 --- a/javascript/ql/test/library-tests/JSDoc/NameResolution/test.expected +++ b/javascript/ql/test/library-tests/JSDoc/NameResolution/test.expected @@ -1,10 +1,10 @@ -| bar.js:5:14:5:14 | x | x | +| bar.js:5:14:5:14 | x | ns.very.long.namespace | | bar.js:5:14:5:18 | x.Foo | ns.very.long.namespace.Foo | -| bar.js:12:14:12:17 | iife | iife | +| bar.js:12:14:12:17 | iife | IIFE | | bar.js:12:14:12:21 | iife.Foo | IIFE.Foo | | closure.js:8:12:8:15 | goog | goog | | closure.js:8:12:8:19 | goog.net | goog.net | | closure.js:8:12:8:28 | goog.net.SomeType | goog.net.SomeType | -| closure.js:9:12:9:14 | net | net | +| closure.js:9:12:9:14 | net | goog.net | | closure.js:9:12:9:23 | net.SomeType | goog.net.SomeType | | closure.js:10:12:10:19 | SomeType | goog.net.SomeType | diff --git a/javascript/ql/test/library-tests/JSDoc/NameResolution/test.ql b/javascript/ql/test/library-tests/JSDoc/NameResolution/test.ql index 1b7ebfdd501a..bb1de953169b 100644 --- a/javascript/ql/test/library-tests/JSDoc/NameResolution/test.ql +++ b/javascript/ql/test/library-tests/JSDoc/NameResolution/test.ql @@ -1,3 +1,3 @@ import javascript -query string test_hasQualifiedName(JSDocNamedTypeExpr expr) { expr.hasQualifiedName(result) } +query string test_hasUnderlyingType(JSDocNamedTypeExpr expr) { expr.hasUnderlyingType(result) } diff --git a/javascript/ql/test/library-tests/TypeAnnotations/JSDoc/JSDocTypeAnnotations.expected b/javascript/ql/test/library-tests/TypeAnnotations/JSDoc/JSDocTypeAnnotations.expected index 8ac3eea2be5f..06afe15ee183 100644 --- a/javascript/ql/test/library-tests/TypeAnnotations/JSDoc/JSDocTypeAnnotations.expected +++ b/javascript/ql/test/library-tests/TypeAnnotations/JSDoc/JSDocTypeAnnotations.expected @@ -2,13 +2,14 @@ test_isString | tst.js:2:12:2:17 | string | test_isNumber | tst.js:3:12:3:17 | number | -test_QualifiedName +test_hasUnderlyingType | VarType | tst.js:9:13:9:19 | VarType | | boolean | tst.js:5:14:5:20 | boolean | | foo | tst.js:4:12:4:14 | foo | | foo.bar | tst.js:4:12:4:18 | foo.bar | | foo.bar.baz | tst.js:4:12:4:22 | foo.bar.baz | | number | tst.js:3:12:3:17 | number | +| number | tst.js:3:12:3:18 | number? | | string | tst.js:2:12:2:17 | string | test_ParameterType | tst.js:7:12:7:12 | x | tst.js:2:12:2:17 | string | diff --git a/javascript/ql/test/library-tests/TypeAnnotations/JSDoc/JSDocTypeAnnotations.ql b/javascript/ql/test/library-tests/TypeAnnotations/JSDoc/JSDocTypeAnnotations.ql index 829435e3220c..fd223ee5a533 100644 --- a/javascript/ql/test/library-tests/TypeAnnotations/JSDoc/JSDocTypeAnnotations.ql +++ b/javascript/ql/test/library-tests/TypeAnnotations/JSDoc/JSDocTypeAnnotations.ql @@ -4,7 +4,7 @@ query TypeAnnotation test_isString() { result.isString() } query TypeAnnotation test_isNumber() { result.isNumber() } -query TypeAnnotation test_QualifiedName(string name) { result.hasQualifiedName(name) } +query TypeAnnotation test_hasUnderlyingType(string name) { result.hasUnderlyingType(name) } query TypeAnnotation test_ParameterType(Parameter p) { result = p.getTypeAnnotation() } diff --git a/javascript/ql/test/library-tests/TypeAnnotations/TSUnresolvedQualifiedName/QualifiedNames.ql b/javascript/ql/test/library-tests/TypeAnnotations/TSUnresolvedQualifiedName/QualifiedNames.ql index e9d66a4afe09..b4d324377bef 100644 --- a/javascript/ql/test/library-tests/TypeAnnotations/TSUnresolvedQualifiedName/QualifiedNames.ql +++ b/javascript/ql/test/library-tests/TypeAnnotations/TSUnresolvedQualifiedName/QualifiedNames.ql @@ -1,5 +1,5 @@ import javascript from TypeAnnotation type, string mod, string name -where type.hasQualifiedName(mod, name) +where type.hasUnderlyingType(mod, name) select type, mod, name diff --git a/javascript/ql/test/library-tests/TypeScript/Ambients/Ambients.expected b/javascript/ql/test/library-tests/TypeScript/Ambients/Ambients.expected index 7a60484a5f72..63e749e97be8 100644 --- a/javascript/ql/test/library-tests/TypeScript/Ambients/Ambients.expected +++ b/javascript/ql/test/library-tests/TypeScript/Ambients/Ambients.expected @@ -1 +1,7 @@ -| tst.ts:38:3:38:19 | resolveAmbient(x) | x should not resolve to a global | +| tst.ts:22:3:22:18 | resolveGlobal(x) | x should resolve to a global variable | +| tst.ts:23:3:23:18 | resolveGlobal(y) | y should resolve to a global variable | +| tst.ts:24:3:24:18 | resolveGlobal(z) | z should resolve to a global variable | +| tst.ts:25:3:25:18 | resolveGlobal(w) | w should resolve to a global variable | +| tst.ts:39:3:39:18 | resolveGlobal(y) | y should resolve to a global variable | +| tst.ts:40:3:40:18 | resolveGlobal(z) | z should resolve to a global variable | +| tst.ts:41:3:41:18 | resolveGlobal(w) | w should resolve to a global variable | diff --git a/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tests.expected b/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tests.expected deleted file mode 100644 index dac5bb14db46..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tests.expected +++ /dev/null @@ -1,17 +0,0 @@ -arrayTypes -| [number, string] | `string \| number` | -| number[] | `number` | -| readonly T[] | `T` | -| readonly number[] | `number` | -| readonly number[][] | `number[]` | -numberIndexTypes -| NumberIndexable | object | -| [number, string] | string \| number | -| number[] | number | -| readonly T[] | T | -| readonly number[] | number | -| readonly number[][] | number[] | -| string | string | -stringIndexTypes -| StringIndexable | object | -tupleTypes diff --git a/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tests.ql b/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tests.ql deleted file mode 100644 index 907a5d78639d..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tests.ql +++ /dev/null @@ -1,11 +0,0 @@ -import javascript - -query predicate arrayTypes(ArrayType array, string elem) { - elem = "`" + array.getArrayElementType() + "`" -} - -query predicate numberIndexTypes(Type type, Type numType) { type.getNumberIndexType() = numType } - -query predicate stringIndexTypes(Type type, Type strType) { type.getStringIndexType() = strType } - -query predicate tupleTypes(TupleType type, Type arrType) { arrType = type.getUnderlyingArrayType() } diff --git a/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tsconfig.json deleted file mode 100644 index 9e26dfeeb6e6..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{} \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tst.ts b/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tst.ts deleted file mode 100644 index 98ca0c2eb216..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ArrayTypes/tst.ts +++ /dev/null @@ -1,19 +0,0 @@ -let plain: number[]; -let readonly: ReadonlyArray; -let tuple: [number, string]; - -interface NumberIndexable { - length: number; - [n: number]: object; -} - -interface StringIndexable { - length: number; - [n: string]: object; -} - -let numberIndexable: NumberIndexable; -let stringIndexable: StringIndexable; - -let readonlySyntax: readonly number[]; -let readonlySyntax2: readonly number[][]; diff --git a/javascript/ql/test/library-tests/TypeScript/BaseTypes/BaseTypes.expected b/javascript/ql/test/library-tests/TypeScript/BaseTypes/BaseTypes.expected deleted file mode 100644 index b6e9c06ec571..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/BaseTypes/BaseTypes.expected +++ /dev/null @@ -1,15 +0,0 @@ -| CEverything | CGenericBase | -| CEverything | IBase | -| CEverything | IGenericSub | -| CGenericSub | CGenericBase | -| CImplements | IBase | -| CImplementsGeneric | IGenericBase | -| CImplementsString | IGenericBase | -| CStringSub | CGenericBase | -| CSub | CBase | -| IEmptySub | IEmpty | -| IGenericSub | IGenericBase | -| IMulti | IBase | -| IMulti | IGenericBase | -| IStringSub | IGenericBase | -| ISub | IBase | diff --git a/javascript/ql/test/library-tests/TypeScript/BaseTypes/BaseTypes.ql b/javascript/ql/test/library-tests/TypeScript/BaseTypes/BaseTypes.ql deleted file mode 100644 index c54177d9c09b..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/BaseTypes/BaseTypes.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from TypeName typename -select typename.getName(), typename.getABaseTypeName().getName() diff --git a/javascript/ql/test/library-tests/TypeScript/BaseTypes/SelfTypes.expected b/javascript/ql/test/library-tests/TypeScript/BaseTypes/SelfTypes.expected deleted file mode 100644 index c82909543dfc..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/BaseTypes/SelfTypes.expected +++ /dev/null @@ -1,17 +0,0 @@ -| CBase | CBase | -| CEverything | CEverything | -| CGenericBase | CGenericBase | -| CGenericSub | CGenericSub | -| CImplements | CImplements | -| CImplementsGeneric | CImplementsGeneric | -| CImplementsString | CImplementsString | -| CStringSub | CStringSub | -| CSub | CSub | -| IBase | IBase | -| IEmpty | IEmpty | -| IEmptySub | IEmptySub | -| IGenericBase | IGenericBase | -| IGenericSub | IGenericSub | -| IMulti | IMulti | -| IStringSub | IStringSub | -| ISub | ISub | diff --git a/javascript/ql/test/library-tests/TypeScript/BaseTypes/SelfTypes.ql b/javascript/ql/test/library-tests/TypeScript/BaseTypes/SelfTypes.ql deleted file mode 100644 index 34a00e7d76ab..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/BaseTypes/SelfTypes.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from TypeName tn -select tn.getName(), tn.getType() diff --git a/javascript/ql/test/library-tests/TypeScript/BaseTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/BaseTypes/tsconfig.json deleted file mode 100644 index 0967ef424bce..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/BaseTypes/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{} diff --git a/javascript/ql/test/library-tests/TypeScript/BaseTypes/tst.ts b/javascript/ql/test/library-tests/TypeScript/BaseTypes/tst.ts deleted file mode 100644 index b2b4a60b4efb..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/BaseTypes/tst.ts +++ /dev/null @@ -1,39 +0,0 @@ -interface IBase { - x: string; -} -interface ISub extends IBase { - y: string; -} - -interface IGenericBase { - w: T; -} -interface IStringSub extends IGenericBase {} -interface IGenericSub extends IGenericBase {} - -class CBase {} -class CSub extends CBase {} - -class CGenericBase {} -class CStringSub extends CGenericBase {} -class CGenericSub extends CGenericBase {} - -interface IMulti extends IBase, IGenericBase {} - -abstract class CImplements implements IBase { - x: string; -} -abstract class CImplementsString implements IGenericBase { - w: string; -} -abstract class CImplementsGeneric implements IGenericBase { - w: Q; -} - -abstract class CEverything extends CGenericBase implements IGenericSub, IBase { - x: string; - w: T; -} - -interface IEmpty {} -interface IEmptySub extends IEmpty {} diff --git a/javascript/ql/test/library-tests/TypeScript/BigInts/tests.expected b/javascript/ql/test/library-tests/TypeScript/BigInts/tests.expected index dcbb70d415a2..3891c6c9f12c 100644 --- a/javascript/ql/test/library-tests/TypeScript/BigInts/tests.expected +++ b/javascript/ql/test/library-tests/TypeScript/BigInts/tests.expected @@ -4,14 +4,7 @@ exprFloatValue | tst.ts:3:25:3:56 | 1000000 ... 000000n | 1.0E30 | exprIntValue | tst.ts:1:25:1:28 | 100n | 100 | -exprWithBigIntType -| tst.ts:1:5:1:11 | hundred | -| tst.ts:2:5:2:12 | bigValue | -| tst.ts:3:5:3:20 | bigNegativeValue | -| tst.ts:5:5:5:14 | bigintType | literalTypeExprIntValue | tst.ts:6:24:6:28 | 1000n | 1000 | typeExpr | tst.ts:5:24:5:29 | bigint | -typeIntValue -| 1000n | 1000 | diff --git a/javascript/ql/test/library-tests/TypeScript/BigInts/tests.ql b/javascript/ql/test/library-tests/TypeScript/BigInts/tests.ql index 233d75f428d3..120ff4434a44 100644 --- a/javascript/ql/test/library-tests/TypeScript/BigInts/tests.ql +++ b/javascript/ql/test/library-tests/TypeScript/BigInts/tests.ql @@ -4,12 +4,8 @@ query predicate exprFloatValue(BigIntLiteral literal, float f) { f = literal.get query predicate exprIntValue(BigIntLiteral literal, int i) { i = literal.getIntValue() } -query predicate exprWithBigIntType(Expr e) { e.getType() instanceof BigIntType } - query predicate literalTypeExprIntValue(BigIntLiteralTypeExpr type, int val) { val = type.getIntValue() } query predicate typeExpr(TypeExpr type) { type.isBigInt() } - -query predicate typeIntValue(BigIntLiteralType type, int i) { type.getIntValue() = i } diff --git a/javascript/ql/test/library-tests/TypeScript/CallResolution/CallResolution.expected b/javascript/ql/test/library-tests/TypeScript/CallResolution/CallResolution.expected deleted file mode 100644 index a942a68076b2..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/CallResolution/CallResolution.expected +++ /dev/null @@ -1,24 +0,0 @@ -| tst.ts:52:3:52:23 | obj.sim ... od(str) | (x: string): number | 0 | -| tst.ts:53:3:53:24 | obj.gen ... od(str) | (x: string): string | 0 | -| tst.ts:54:3:54:24 | obj.gen ... od(num) | (x: number): number | 0 | -| tst.ts:55:3:55:27 | obj.ove ... od(num) | (x: number): number | 0 | -| tst.ts:56:3:56:27 | obj.ove ... od(str) | (x: string): string | 1 | -| tst.ts:57:3:57:26 | obj.ove ... hod([]) | (x: any): any | 2 | -| tst.ts:58:3:58:36 | obj.gen ... ([num]) | (x: number[]): number | 0 | -| tst.ts:59:3:59:39 | obj.gen ... : str}) | (x: Box): string | 1 | -| tst.ts:60:3:60:34 | obj.gen ... od(num) | (x: any): any | 2 | -| tst.ts:64:3:64:23 | obj.sim ... od(str) | (x: string): number | 0 | -| tst.ts:65:3:65:24 | obj.gen ... od(str) | (x: string): string | 0 | -| tst.ts:66:3:66:24 | obj.gen ... od(num) | (x: number): number | 0 | -| tst.ts:67:3:67:27 | obj.ove ... od(num) | (x: number): number | 0 | -| tst.ts:68:3:68:27 | obj.ove ... od(str) | (x: string): string | 1 | -| tst.ts:69:3:69:36 | obj.gen ... ([num]) | (x: number[]): number | 0 | -| tst.ts:70:3:70:39 | obj.gen ... : str}) | (x: Box): string | 1 | -| tst.ts:74:3:74:28 | new Sim ... or(str) | new (x: string): SimpleConstructor | 0 | -| tst.ts:75:3:75:29 | new Gen ... or(str) | new (x: string): GenericConstructor | 0 | -| tst.ts:76:3:76:29 | new Gen ... or(num) | new (x: number): GenericConstructor | 0 | -| tst.ts:77:3:77:37 | new Ove ... m, num) | new (x: number, y: number): OverloadedConstructor | 0 | -| tst.ts:78:3:78:37 | new Ove ... r, str) | new (x: string, y: string): OverloadedConstructor | 1 | -| tst.ts:79:3:79:48 | new Gen ... [str]) | new (x: string[], y: string[]): GenericOverloadedConstructor | 0 | -| tst.ts:80:3:80:54 | new Gen ... : num}) | new (x: Box, y: Box): GenericOverloadedConstructor { x: T } - -interface TestInterface { - simpleMethod(x: string): number; - - genericMethod(x: T): T; - - overloadedMethod(x: number): number; - overloadedMethod(x: string): string; - overloadedMethod(x: any): any; - - genericOverloadedMethod(x: T[]): T; - genericOverloadedMethod(x: Box): T; - genericOverloadedMethod(x: any): any; -} - -class TestClass { - simpleMethod(x: string): number { return x.length } - - genericMethod(x: T): T { return x; } - - overloadedMethod(x: number): number; - overloadedMethod(x: string): string; - overloadedMethod(x: any): any { return x; } - - genericOverloadedMethod(x: T[]): T; - genericOverloadedMethod(x: Box): T; - genericOverloadedMethod(x: any): any { return x.x || x[0] || null; } -} - -class SimpleConstructor { - constructor(x: string) {} -} - -class GenericConstructor { - constructor(x: T) {} -} - -class OverloadedConstructor { - constructor(x: number, y: number); - constructor(x: string, y: string); - constructor(x: any, y: any) {} -} - -class GenericOverloadedConstructor { - constructor(x: T[], y: T[]); - constructor(x: Box, y: Box); - constructor(x: any, y: any) {} -} - -function useTestInterface(obj: TestInterface, str: string, num: number) { - obj.simpleMethod(str); - obj.genericMethod(str); - obj.genericMethod(num); - obj.overloadedMethod(num); - obj.overloadedMethod(str); - obj.overloadedMethod([]); - obj.genericOverloadedMethod([num]); - obj.genericOverloadedMethod({x: str}); - obj.genericOverloadedMethod(num); -} - -function useTestClass(obj: TestClass, str: string, num: number) { - obj.simpleMethod(str); - obj.genericMethod(str); - obj.genericMethod(num); - obj.overloadedMethod(num); - obj.overloadedMethod(str); - obj.genericOverloadedMethod([num]); - obj.genericOverloadedMethod({x: str}); -} - -function testConstructors(str: string, num: number) { - new SimpleConstructor(str); - new GenericConstructor(str); - new GenericConstructor(num); - new OverloadedConstructor(num, num); - new OverloadedConstructor(str, str); - new GenericOverloadedConstructor([str], [str]); - new GenericOverloadedConstructor({x: num}, {x: num}); -} - -function testCallback(callback: (x: string) => U): U { - return callback("str"); -} diff --git a/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/test.expected b/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/test.expected deleted file mode 100644 index 2c6bf9153a8b..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/test.expected +++ /dev/null @@ -1,131 +0,0 @@ -test_ExprSignature -| tst.ts:2:4:2:4 | x | number | -| tst.ts:6:4:6:4 | x | number | -| tst.ts:7:4:7:4 | x | string | -| tst.ts:8:4:8:4 | x | any | -| tst.ts:12:8:12:8 | x | number | -| tst.ts:16:8:16:8 | x | number | -| tst.ts:17:8:17:8 | x | any | -| tst.ts:21:3:21:28 | method( ... string; | (x: number): string | -| tst.ts:21:10:21:10 | x | number | -| tst.ts:23:3:23:38 | overloa ... number; | (x: any): any | -| tst.ts:23:3:23:38 | overloa ... number; | (x: number): number | -| tst.ts:23:3:23:38 | overloa ... number; | (x: string): string | -| tst.ts:23:20:23:20 | x | number | -| tst.ts:24:3:24:38 | overloa ... string; | (x: any): any | -| tst.ts:24:3:24:38 | overloa ... string; | (x: number): number | -| tst.ts:24:3:24:38 | overloa ... string; | (x: string): string | -| tst.ts:24:20:24:20 | x | string | -| tst.ts:25:3:25:32 | overloa ... ): any; | (x: any): any | -| tst.ts:25:3:25:32 | overloa ... ): any; | (x: number): number | -| tst.ts:25:3:25:32 | overloa ... ): any; | (x: string): string | -| tst.ts:25:20:25:20 | x | any | -| tst.ts:28:5:28:5 | m | Method | -| tst.ts:29:1:29:1 | m | Method | -| tst.ts:29:1:29:8 | m.method | (x: number): string | -| tst.ts:29:1:29:12 | m.method(42) | string | -| tst.ts:29:10:29:11 | 42 | 42 | -| tst.ts:30:1:30:1 | m | Method | -| tst.ts:30:1:30:18 | m.overloadedMethod | (x: any): any | -| tst.ts:30:1:30:18 | m.overloadedMethod | (x: number): number | -| tst.ts:30:1:30:18 | m.overloadedMethod | (x: string): string | -| tst.ts:30:1:30:25 | m.overl ... ("foo") | string | -| tst.ts:30:20:30:24 | "foo" | "foo" | -| tst.ts:33:3:33:10 | callback | (x: number): string | -| tst.ts:33:13:33:33 | (x: num ... string | (x: number): string | -| tst.ts:33:14:33:14 | x | number | -| tst.ts:37:3:37:18 | method(x: T): T; | (x: T): T | -| tst.ts:37:10:37:10 | x | T | -| tst.ts:40:10:40:12 | foo | (g: Generic): string | -| tst.ts:40:14:40:14 | g | Generic | -| tst.ts:41:10:41:10 | g | Generic | -| tst.ts:41:10:41:17 | g.method | (x: string): string | -| tst.ts:41:10:41:24 | g.method("foo") | string | -| tst.ts:41:19:41:23 | "foo" | "foo" | -| tst.ts:44:15:44:15 | C | C | -| tst.ts:45:3:45:25 | constru ... tring); | any | -| tst.ts:45:15:45:15 | x | string | -| tst.ts:46:3:46:25 | constru ... umber); | any | -| tst.ts:46:15:46:15 | x | number | -| tst.ts:50:3:50:36 | method( ... ing[]); | (x: number, ...y: string[]): any | -| tst.ts:50:10:50:10 | x | number | -| tst.ts:50:24:50:24 | y | string[] | -| tst.ts:51:4:51:4 | x | number | -| tst.ts:51:18:51:18 | y | string[] | -| tst.ts:52:7:52:7 | x | number | -| tst.ts:52:21:52:21 | y | string[] | -| tst.ts:54:3:54:34 | method2 ... ing[]); | (x: number, y: string[]): any | -| tst.ts:54:11:54:11 | x | number | -| tst.ts:54:22:54:22 | y | string[] | -| tst.ts:55:3:55:32 | method3 ... tring); | (x: number, y: string): any | -| tst.ts:55:11:55:11 | x | number | -| tst.ts:55:22:55:22 | y | string | -| tst.ts:59:3:59:25 | method( ... ing[]); | (...y: string[]): any | -| tst.ts:59:13:59:13 | y | string[] | -| tst.ts:60:7:60:7 | y | string[] | -| tst.ts:61:10:61:10 | y | string[] | -| tst.ts:63:3:63:23 | method2 ... ing[]); | (y: string[]): any | -| tst.ts:63:11:63:11 | y | string[] | -| tst.ts:64:3:64:21 | method3(y: string); | (y: string): any | -| tst.ts:64:11:64:11 | y | string | -test_TypeReferenceSig -| Callable | function | 0 | (x: number): string | -| Newable | constructor | 0 | new (x: number): any | -| OnlyRestParams | constructor | 0 | new (...y: string[]): any | -| OnlyRestParams | function | 0 | (...y: string[]): any | -| OverloadedCallable | function | 0 | (x: number): number | -| OverloadedCallable | function | 1 | (x: string): string | -| OverloadedCallable | function | 2 | (x: any): any | -| OverloadedNewable | constructor | 0 | new (x: number): OverloadedNewable | -| OverloadedNewable | constructor | 1 | new (x: any): any | -| WithRestParams | constructor | 0 | new (x: number, ...y: string[]): any | -| WithRestParams | function | 0 | (x: number, ...y: string[]): any | -test_FunctionCallSig -| tst.ts:2:3:2:22 | (x: number): string; | (x: number): string | -| tst.ts:6:3:6:22 | (x: number): number; | (x: number): number | -| tst.ts:7:3:7:22 | (x: string): string; | (x: string): string | -| tst.ts:8:3:8:16 | (x: any): any; | (x: any): any | -| tst.ts:12:3:12:23 | new (x: ... ): any; | new (x: number): any | -| tst.ts:16:3:16:37 | new (x: ... ewable; | new (x: number): OverloadedNewable | -| tst.ts:17:3:17:20 | new (x: any): any; | new (x: any): any | -| tst.ts:21:3:21:28 | method( ... string; | (x: number): string | -| tst.ts:23:3:23:38 | overloa ... number; | (x: number): number | -| tst.ts:24:3:24:38 | overloa ... string; | (x: string): string | -| tst.ts:25:3:25:32 | overloa ... ): any; | (x: any): any | -| tst.ts:33:13:33:33 | (x: num ... string | (x: number): string | -| tst.ts:37:3:37:18 | method(x: T): T; | (x: T): T | -| tst.ts:40:1:42:1 | functio ... oo");\\n} | (g: Generic): string | -| tst.ts:45:3:45:25 | constru ... tring); | new (x: string): C | -| tst.ts:46:3:46:25 | constru ... umber); | new (x: number): C | -| tst.ts:50:3:50:36 | method( ... ing[]); | (x: number, ...y: string[]): any | -| tst.ts:51:3:51:30 | (x: num ... ing[]); | (x: number, ...y: string[]): any | -| tst.ts:52:3:52:33 | new(x: ... ing[]); | new (x: number, ...y: string[]): any | -| tst.ts:54:3:54:34 | method2 ... ing[]); | (x: number, y: string[]): any | -| tst.ts:55:3:55:32 | method3 ... tring); | (x: number, y: string): any | -| tst.ts:59:3:59:25 | method( ... ing[]); | (...y: string[]): any | -| tst.ts:60:3:60:19 | (...y: string[]); | (...y: string[]): any | -| tst.ts:61:3:61:22 | new(...y: string[]); | new (...y: string[]): any | -| tst.ts:63:3:63:23 | method2 ... ing[]); | (y: string[]): any | -| tst.ts:64:3:64:21 | method3(y: string); | (y: string): any | -test_getRestParameterType -| (...y: string[]): any | string | -| (x: number, ...y: string[]): any | string | -| new (...y: string[]): any | string | -| new (x: number, ...y: string[]): any | string | -test_getRestParameterArray -| (...y: string[]): any | string[] | -| (x: number, ...y: string[]): any | string[] | -| new (...y: string[]): any | string[] | -| new (x: number, ...y: string[]): any | string[] | -test_RestSig_getParameter -| (...y: string[]): any | 0 | y | string | -| (x: number, ...y: string[]): any | 0 | x | number | -| (x: number, ...y: string[]): any | 1 | y | string | -| new (...y: string[]): any | 0 | y | string | -| new (x: number, ...y: string[]): any | 0 | x | number | -| new (x: number, ...y: string[]): any | 1 | y | string | -test_RestSig_numRequiredParams -| (...y: string[]): any | 0 | -| (x: number, ...y: string[]): any | 1 | -| new (...y: string[]): any | 0 | -| new (x: number, ...y: string[]): any | 1 | diff --git a/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/test.ql b/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/test.ql deleted file mode 100644 index 03cc288f0540..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/test.ql +++ /dev/null @@ -1,41 +0,0 @@ -import javascript - -string getASignatureOrElseType(Type t) { - result = t.getASignature(_).toString() - or - not exists(t.getASignature(_)) and - result = t.toString() -} - -query predicate test_ExprSignature(Expr expr, string type) { - not exists(MethodDeclaration decl | decl.getNameExpr() = expr) and - not exists(DotExpr dot | expr = dot.getPropertyNameExpr()) and - type = getASignatureOrElseType(expr.getType()) -} - -query predicate test_TypeReferenceSig( - TypeReference type, SignatureKind kind, int n, CallSignatureType sig -) { - sig = type.getSignature(kind, n) -} - -query predicate test_FunctionCallSig(Function f, CallSignatureType sig) { - sig = f.getCallSignature() -} - -query Type test_getRestParameterType(CallSignatureType sig) { result = sig.getRestParameterType() } - -query Type test_getRestParameterArray(CallSignatureType sig) { - result = sig.getRestParameterArrayType() -} - -query predicate test_RestSig_getParameter(CallSignatureType sig, int n, string name, Type type) { - sig.hasRestParameter() and - name = sig.getParameterName(n) and - type = sig.getParameter(n) -} - -query int test_RestSig_numRequiredParams(CallSignatureType sig) { - sig.hasRestParameter() and - result = sig.getNumRequiredParameter() -} diff --git a/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/tsconfig.json deleted file mode 100644 index 0967ef424bce..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{} diff --git a/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/tst.ts b/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/tst.ts deleted file mode 100644 index ed0ab3bcfd60..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/CallSignatureTypes/tst.ts +++ /dev/null @@ -1,65 +0,0 @@ -interface Callable { - (x: number): string; -} - -interface OverloadedCallable { - (x: number): number; - (x: string): string; - (x: any): any; -} - -interface Newable { - new (x: number): any; -} - -interface OverloadedNewable { - new (x: number): OverloadedNewable; - new (x: any): any; -} - -interface Method { - method(x: number): string; - - overloadedMethod(x: number): number; - overloadedMethod(x: string): string; - overloadedMethod(x: any): any; -} - -let m: Method; -m.method(42); -m.overloadedMethod("foo"); - -interface FunctionTypeField { - callback: (x: number) => string; -} - -interface Generic { - method(x: T): T; -} - -function foo(g: Generic) { - return g.method("foo"); -} - -declare class C { - constructor(x: string); - constructor(x: number); -} - -interface WithRestParams { - method(x: number, ...y: string[]); - (x: number, ...y: string[]); - new(x: number, ...y: string[]); - - method2(x: number, y: string[]); - method3(x: number, y: string); -} - -interface OnlyRestParams { - method(...y: string[]); - (...y: string[]); - new(...y: string[]); - - method2(y: string[]); - method3(y: string); -} diff --git a/javascript/ql/test/library-tests/TypeScript/DeclarationFiles/TypeResolution.expected b/javascript/ql/test/library-tests/TypeScript/DeclarationFiles/TypeResolution.expected deleted file mode 100644 index 470c051d2285..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/DeclarationFiles/TypeResolution.expected +++ /dev/null @@ -1,8 +0,0 @@ -| client1.ts:4:9:4:19 | F.Component | Component in module 'framework1' | -| client1.ts:5:9:5:29 | Util.De ... mponent | Util.DefaultComponent in global scope | -| client2.ts:4:9:4:19 | F.Component | Component in module 'framework2' | -| client2.ts:5:9:5:30 | Util2.D ... mponent | Util2.DefaultComponent in global scope | -| client2_lazy.ts:4:9:4:19 | F.Component | Component in module 'framework2' | -| client2_lazy.ts:5:9:5:30 | Util2.D ... mponent | Util2.DefaultComponent in global scope | -| declare-module-client2.ts:5:8:5:8 | C | C in module 'foo' | -| declare-module-client.ts:5:8:5:8 | C | C in module 'foo' | diff --git a/javascript/ql/test/library-tests/TypeScript/DeclarationFiles/TypeResolution.ql b/javascript/ql/test/library-tests/TypeScript/DeclarationFiles/TypeResolution.ql deleted file mode 100644 index dbaf61b998f6..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/DeclarationFiles/TypeResolution.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from TypeAccess access -select access, access.getTypeName() diff --git a/javascript/ql/test/library-tests/TypeScript/EmbeddedInScript/Test.expected b/javascript/ql/test/library-tests/TypeScript/EmbeddedInScript/Test.expected index 2bb7faf59eb9..c2ef20983621 100644 --- a/javascript/ql/test/library-tests/TypeScript/EmbeddedInScript/Test.expected +++ b/javascript/ql/test/library-tests/TypeScript/EmbeddedInScript/Test.expected @@ -1,34 +1,6 @@ classDeclaration | test.vue:3:18:5:3 | class M ... er;\\n } | | test_tsx.vue:3:18:5:3 | class M ... er;\\n } | -exprType -| htmlfile.html:4:22:4:24 | foo | () => void | -| htmlfile.html:4:33:4:41 | "./other" | any | -| htmlfile.html:5:17:5:22 | result | number[] | -| htmlfile.html:5:26:5:28 | foo | () => void | -| htmlfile.html:5:26:5:30 | foo() | void | -| htmlfile.html:5:26:5:42 | foo() as number[] | number[] | -| other.ts:1:8:1:16 | Component | typeof default in test.vue | -| other.ts:1:23:1:34 | "./test.vue" | any | -| other.ts:2:8:2:19 | ComponentTsx | typeof default in test_tsx.vue | -| other.ts:2:26:2:41 | "./test_tsx.vue" | any | -| other.ts:4:1:4:15 | new Component() | MyComponent | -| other.ts:4:5:4:13 | Component | typeof default in test.vue | -| other.ts:5:1:5:18 | new ComponentTsx() | MyComponentTsx | -| other.ts:5:5:5:16 | ComponentTsx | typeof default in test_tsx.vue | -| other.ts:7:17:7:19 | foo | () => void | -| test.vue:2:15:2:19 | other | typeof other.ts | -| test.vue:2:26:2:34 | "./other" | any | -| test.vue:3:24:3:34 | MyComponent | MyComponent | -| test.vue:4:7:4:7 | x | number | -| test_tsx.vue:2:15:2:19 | other | typeof other.ts | -| test_tsx.vue:2:26:2:34 | "./other" | any | -| test_tsx.vue:3:24:3:37 | MyComponentTsx | MyComponentTsx | -| test_tsx.vue:4:7:4:7 | x | number | -symbols -| other.ts:1:1:8:0 | | other.ts | -| test.vue:2:3:6:0 | | test.vue | -| test_tsx.vue:2:3:6:0 | | test_tsx.vue | importTarget | htmlfile.html:4:13:4:42 | import ... other"; | other.ts:1:1:8:0 | | | other.ts:1:1:1:35 | import ... t.vue"; | test.vue:2:3:6:0 | | diff --git a/javascript/ql/test/library-tests/TypeScript/EmbeddedInScript/Test.ql b/javascript/ql/test/library-tests/TypeScript/EmbeddedInScript/Test.ql index 43a718bf77b9..e333dc900d99 100644 --- a/javascript/ql/test/library-tests/TypeScript/EmbeddedInScript/Test.ql +++ b/javascript/ql/test/library-tests/TypeScript/EmbeddedInScript/Test.ql @@ -2,8 +2,4 @@ import javascript query ClassDefinition classDeclaration() { any() } -query Type exprType(Expr e) { result = e.getType() } - -query predicate symbols(Module mod, CanonicalName name) { ast_node_symbol(mod, name) } - query predicate importTarget(Import imprt, Module mod) { imprt.getImportedModule() = mod } diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/Types.expected b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/Types.expected deleted file mode 100644 index b769d79a261b..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/Types.expected +++ /dev/null @@ -1,77 +0,0 @@ -| After | -| AfterX | -| Before | -| BeforeX | -| Box> | -| Box | -| Box | -| Box | -| Box | -| C | -| C | -| Expand | -| Expand | -| ExpandUsingObjectLiteral | -| ExpandUsingObjectLiteral | -| Expansive | -| Expansive | -| Expansive | -| Expansive | -| Expansive | -| Expansive | -| ExpansiveA | -| ExpansiveA | -| ExpansiveA | -| ExpansiveA | -| ExpansiveB | -| ExpansiveB | -| ExpansiveB | -| ExpansiveB | -| ExpansiveB | -| ExpansiveB | -| ExpansiveByInference | -| ExpansiveByInference | -| ExpansiveC | -| ExpansiveC | -| ExpansiveC | -| ExpansiveC | -| ExpansiveC | -| ExpansiveC | -| ExpansiveConstructSignature | -| ExpansiveConstructSignature | -| ExpansiveD | -| ExpansiveD | -| ExpansiveD | -| ExpansiveD | -| ExpansiveFunctionType | -| ExpansiveFunctionType | -| ExpansiveMethod | -| ExpansiveMethod | -| ExpansiveParameter | -| ExpansiveParameter | -| ExpansiveSignature | -| ExpansiveSignature | -| ExpansiveSignatureTypeBound | -| ExpansiveSignatureTypeBound | -| ExpansiveX | -| ExpansiveX | -| NonExpansive> | -| NonExpansive | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | -| T[] | diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/Types.ql b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/Types.ql deleted file mode 100644 index 6890e2937766..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/Types.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from TypeReference type -select type diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/dummy.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/dummy.ts deleted file mode 100644 index 91779e66b25f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/dummy.ts +++ /dev/null @@ -1 +0,0 @@ -export let x = 1; \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_by_inference.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_by_inference.ts deleted file mode 100644 index 62e41ce4c679..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_by_inference.ts +++ /dev/null @@ -1,8 +0,0 @@ -import * as dummy from "./dummy"; - -class ExpansiveByInference { - x: T; - y = new ExpansiveByInference([this.x]); // Inferred to be `ExpansiveByInference` - - constructor(arg: T) {} -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_class.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_class.ts deleted file mode 100644 index 354a9f9230c3..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_class.ts +++ /dev/null @@ -1,5 +0,0 @@ -import * as dummy from "./dummy"; - -class C { - x: C; -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_object_literal.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_object_literal.ts deleted file mode 100644 index 9225f1e1bbf3..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_object_literal.ts +++ /dev/null @@ -1,7 +0,0 @@ -import * as dummy from "./dummy"; - -interface ExpandUsingObjectLiteral { - x: { - foo: ExpandUsingObjectLiteral - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_signature.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_signature.ts deleted file mode 100644 index 6bdfd8e1f2aa..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/expansive_signature.ts +++ /dev/null @@ -1,25 +0,0 @@ -import * as dummy from "./dummy"; - -interface ExpansiveSignature { - x: { (): ExpansiveSignature; } -} - -interface ExpansiveParameter { - x: { (param: ExpansiveParameter): void; } -} - -interface ExpansiveConstructSignature { - x: { new(): ExpansiveConstructSignature; } -} - -interface ExpansiveMethod { - method(): ExpansiveMethod; -} - -interface ExpansiveFunctionType { - x: () => ExpansiveFunctionType; -} - -interface ExpansiveSignatureTypeBound { - foo : { >(x: G): G }; -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/leading_into_expansion.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/leading_into_expansion.ts deleted file mode 100644 index 0df863991dba..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/leading_into_expansion.ts +++ /dev/null @@ -1,13 +0,0 @@ -import * as dummy from "./dummy"; - -interface Before { - x: Expansive; -} - -interface Expansive { - x: Expansive; -} - -interface After { - x: Expansive; -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/mutual.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/mutual.ts deleted file mode 100644 index 05682c459281..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/mutual.ts +++ /dev/null @@ -1,17 +0,0 @@ -import * as dummy from "./dummy"; - -interface ExpansiveA { - x: ExpansiveB; -} - -interface ExpansiveB { - x: ExpansiveA; -} - - -interface ExpansiveC { - x: ExpansiveD; -} -interface ExpansiveD { - x: ExpansiveC; -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/mutual_multigraph.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/mutual_multigraph.ts deleted file mode 100644 index 22a2917fe412..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/mutual_multigraph.ts +++ /dev/null @@ -1,24 +0,0 @@ -import * as dummy from "./dummy"; - -// The expansive edge may be preceded by non-expansive edges. - -interface ExpansiveA { - a: ExpansiveB; - b: ExpansiveB; - x: ExpansiveB; -} - -interface ExpansiveB { - x: ExpansiveA; -} - - -interface ExpansiveC { - x: ExpansiveD; -} - -interface ExpansiveD { - a: ExpansiveC; - b: ExpansiveC; - x: ExpansiveC; -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/shared_non_expansive.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/shared_non_expansive.ts deleted file mode 100644 index 86dab87ad90e..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/shared_non_expansive.ts +++ /dev/null @@ -1,12 +0,0 @@ -import * as dummy from "./dummy"; - -// Box is not expansive by itself but expansions may go "through" it. -interface Box { - x: S; -} - -// A too simple algorithm might classify this as expansive. -interface NonExpansive { - x: NonExpansive>; - y: Box; -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/simple.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/simple.ts deleted file mode 100644 index 8421124d7b83..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/simple.ts +++ /dev/null @@ -1,5 +0,0 @@ -import * as dummy from "./dummy"; - -interface Expansive { - x: Expansive; -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/through_non_expansive.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/through_non_expansive.ts deleted file mode 100644 index 8724e9fd6c91..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/through_non_expansive.ts +++ /dev/null @@ -1,10 +0,0 @@ -import * as dummy from "./dummy"; - -interface Expand { - x: Box> -} - -// Box is not expansive by itself but expansions may go "through" it. -interface Box { - x: S; -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/tsconfig.json deleted file mode 100644 index 0967ef424bce..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{} diff --git a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/used_from_expansion.ts b/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/used_from_expansion.ts deleted file mode 100644 index 8ab40e5944a9..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExpansiveTypes/used_from_expansion.ts +++ /dev/null @@ -1,15 +0,0 @@ -import * as dummy from "./dummy"; - -interface BeforeX { - x: number; -} - -interface ExpansiveX { - a: BeforeX; - x: ExpansiveX; - b: BeforeX; -} - -interface AfterX { - x: string; -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/BaseTypes.expected b/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/BaseTypes.expected deleted file mode 100644 index 48d4d2cf1d1e..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/BaseTypes.expected +++ /dev/null @@ -1,3 +0,0 @@ -| B in module 'mylib' | A in module 'mylib' | -| C in module 'mylib' | B in module 'mylib' | -| D in module 'mylib' | C in module 'mylib' | diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/BaseTypes.ql b/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/BaseTypes.ql deleted file mode 100644 index b6595b03cba4..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/BaseTypes.ql +++ /dev/null @@ -1,5 +0,0 @@ -import javascript - -from TypeName tn -where tn.hasQualifiedName("mylib", _) -select tn, tn.getABaseTypeName() diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/node_modules/@types/mylib/index.d.ts b/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/node_modules/@types/mylib/index.d.ts deleted file mode 100644 index 62cf0bacbf3d..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/node_modules/@types/mylib/index.d.ts +++ /dev/null @@ -1,4 +0,0 @@ -export interface A {} -export interface B extends A {} -export interface C extends B {} -export interface D extends C {} diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/options b/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/options deleted file mode 100644 index e59bfd7d72ef..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/options +++ /dev/null @@ -1 +0,0 @@ -semmle-extractor-options:--exclude node_modules/** diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/tsconfig.json deleted file mode 100644 index c4df0713286c..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/tsconfig.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "compilerOptions": { - "baseUrl": "./" - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/tst.ts b/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/tst.ts deleted file mode 100644 index 698f658d1064..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalBaseTypes/tst.ts +++ /dev/null @@ -1,3 +0,0 @@ -import { D } from "mylib"; - -export var foo: D = null; diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/augmentation.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/augmentation.ts deleted file mode 100644 index 36ece00b15da..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/augmentation.ts +++ /dev/null @@ -1,9 +0,0 @@ -import { ExternalType1, Augmentation } from "esmodule"; - -declare module "esmodule" { - export interface Augmentation { - x: ExternalType1; - } -} - -let x: Augmentation; diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_esmodule.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_esmodule.ts deleted file mode 100644 index c90291d0a0b8..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_esmodule.ts +++ /dev/null @@ -1,16 +0,0 @@ -import { ExternalType1, externalSymbol } from "esmodule"; - -function f(arg: ExternalType1) { - let y = arg.x; // y should be ExternalType2 -} - -let foo = 5; - -let bar: { x: number }; - -interface InternalType { - x: number; - [externalSymbol]: number; -} -let symb = externalSymbol; - diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_esmodule_extra.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_esmodule_extra.ts deleted file mode 100644 index 8fda57d2d783..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_esmodule_extra.ts +++ /dev/null @@ -1,7 +0,0 @@ -import { OtherClass } from "esmodule/otherfile"; -import { UtilClass } from "esmodule/util"; -import { UtilExtraClass } from "esmodule/util/extra"; - -let c1 = new OtherClass(); -let c2 = new UtilClass(); -let c3 = new UtilExtraClass(); diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_legacy_global.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_legacy_global.ts deleted file mode 100644 index ee07ed41dc5f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_legacy_global.ts +++ /dev/null @@ -1,3 +0,0 @@ -/// - -let d = new LegacyGlobals.LegacySubclass(); diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_legacy_module.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_legacy_module.ts deleted file mode 100644 index f0f45868d660..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_legacy_module.ts +++ /dev/null @@ -1,3 +0,0 @@ -import { LegacyClass } from "legacy"; - -let c: LegacyClass; diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_modern_global.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_modern_global.ts deleted file mode 100644 index b849a9b3b451..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_modern_global.ts +++ /dev/null @@ -1,3 +0,0 @@ -/// - -let d = new ModernGlobals.ModernSubclass(); diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_modern_module.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_modern_module.ts deleted file mode 100644 index a79aded70600..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/client_modern_module.ts +++ /dev/null @@ -1,3 +0,0 @@ -import { ModernClass } from "modern"; - -let c: ModernClass; \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/index.d.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/index.d.ts deleted file mode 100644 index 577a29e73b79..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/index.d.ts +++ /dev/null @@ -1,10 +0,0 @@ -export interface ExternalType1 { - x: ExternalType2; -} - -export interface ExternalType2 { - x: number; - y: number; -} - -export const externalSymbol: unique symbol; diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/otherfile.d.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/otherfile.d.ts deleted file mode 100644 index 75147c48c6cb..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/otherfile.d.ts +++ /dev/null @@ -1 +0,0 @@ -export declare class OtherClass {} diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/util/extra.d.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/util/extra.d.ts deleted file mode 100644 index 358c567c5f59..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/util/extra.d.ts +++ /dev/null @@ -1 +0,0 @@ -export declare class UtilExtraClass {} diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/util/index.d.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/util/index.d.ts deleted file mode 100644 index 90c9487a34b7..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/esmodule/util/index.d.ts +++ /dev/null @@ -1 +0,0 @@ -export declare class UtilClass {} diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/legacy/index.d.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/legacy/index.d.ts deleted file mode 100644 index f90170361347..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/legacy/index.d.ts +++ /dev/null @@ -1,13 +0,0 @@ -declare namespace __Legacy { - export class LegacyClass {} -} - -declare module "legacy" { - export = __Legacy; -} - -declare namespace LegacyGlobals { - import Legacy = __Legacy; - - class LegacySubclass extends Legacy.LegacyClass {} -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/modern/index.d.ts b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/modern/index.d.ts deleted file mode 100644 index f02e5b7601cf..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/node_modules/@types/modern/index.d.ts +++ /dev/null @@ -1,12 +0,0 @@ -export = Modern; -export as namespace Modern; - -declare namespace Modern { - class ModernClass {} -} - -declare global { - namespace ModernGlobals { - class ModernSubclass extends Modern.ModernClass {} - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/options b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/options deleted file mode 100644 index e59bfd7d72ef..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/options +++ /dev/null @@ -1 +0,0 @@ -semmle-extractor-options:--exclude node_modules/** diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/tests.expected b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/tests.expected deleted file mode 100644 index 26ee4c9b67cb..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/tests.expected +++ /dev/null @@ -1,28 +0,0 @@ -globalQualifiedNames -| LegacyClass | __Legacy.LegacyClass | -| LegacySubclass | LegacyGlobals.LegacySubclass | -| ModernClass | Modern.ModernClass | -| ModernSubclass | ModernGlobals.ModernSubclass | -moduleQualifiedName -| Augmentation | esmodule | Augmentation | -| ExternalType1 | esmodule | ExternalType1 | -| ExternalType2 | esmodule | ExternalType2 | -| LegacyClass | legacy | LegacyClass | -| ModernClass | modern | ModernClass | -| OtherClass | esmodule/otherfile | OtherClass | -| UtilClass | esmodule/util | UtilClass | -| UtilExtraClass | esmodule/util/extra | UtilExtraClass | -types -| Augmentation | defined in augmentation.ts | -| ExternalType1 | has no definition | -| ExternalType2 | has no definition | -| InternalType | defined in client_esmodule.ts | -| LegacyClass | has no definition | -| LegacySubclass | has no definition | -| ModernClass | has no definition | -| ModernSubclass | has no definition | -| OtherClass | has no definition | -| UtilClass | has no definition | -| UtilExtraClass | has no definition | -uniqueSymbols -| typeof externalSymbol | esmodule | externalSymbol | diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/tests.ql b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/tests.ql deleted file mode 100644 index aedebb37bc90..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/tests.ql +++ /dev/null @@ -1,26 +0,0 @@ -import javascript - -query predicate globalQualifiedNames(TypeReference type, string globalName) { - type.hasQualifiedName(globalName) and - not type.hasTypeArguments() -} - -query predicate moduleQualifiedName(TypeReference type, string moduleName, string exportedName) { - type.hasQualifiedName(moduleName, exportedName) and - not type.hasTypeArguments() -} - -string getDefinition(TypeReference ref) { - if exists(ref.getADefinition()) - then result = "defined in " + ref.getADefinition().getFile().getBaseName() - else result = "has no definition" -} - -query predicate types(TypeReference type, string def) { - not type.hasTypeArguments() and - def = getDefinition(type) -} - -query predicate uniqueSymbols(UniqueSymbolType symbol, string moduleName, string exportedName) { - symbol.hasQualifiedName(moduleName, exportedName) -} diff --git a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/ExternalTypes/tsconfig.json deleted file mode 100644 index c4df0713286c..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ExternalTypes/tsconfig.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "compilerOptions": { - "baseUrl": "./" - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/HasQualifiedNameFallback/Test.expected b/javascript/ql/test/library-tests/TypeScript/HasQualifiedNameFallback/Test.expected index 5ee97e2dfb59..3781aea96e20 100644 --- a/javascript/ql/test/library-tests/TypeScript/HasQualifiedNameFallback/Test.expected +++ b/javascript/ql/test/library-tests/TypeScript/HasQualifiedNameFallback/Test.expected @@ -1,13 +1,15 @@ -hasQualifiedNameModule -| default-import | default | tst.ts:11:9:11:21 | DefaultImport | +hasUnderlyingTypeModule +| default-import | | tst.ts:11:9:11:21 | DefaultImport | +| global | UnresolvedName | tst.ts:12:9:12:22 | UnresolvedName | +| import-assign | | tst.ts:10:9:10:11 | asn | | import-assign | Foo | tst.ts:10:9:10:15 | asn.Foo | | named-import | Name1 | tst.ts:7:9:7:13 | Name1 | | named-import | Name1 | tst.ts:13:9:13:13 | Name1 | | named-import | Name1 | tst.ts:13:9:13:21 | Name1 | | named-import | Name2 | tst.ts:8:9:8:13 | Name2 | +| namespace-import | | tst.ts:9:9:9:17 | namespace | | namespace-import | Foo | tst.ts:9:9:9:21 | namespace.Foo | -| tst.ts | ExportedClass | relative.ts:4:8:4:20 | ExportedClass | -hasQualifiedNameGlobal +hasUnderlyingTypeGlobal | UnresolvedName | tst.ts:12:9:12:22 | UnresolvedName | paramExample | tst.ts:7:5:7:6 | x1 | diff --git a/javascript/ql/test/library-tests/TypeScript/HasQualifiedNameFallback/Test.ql b/javascript/ql/test/library-tests/TypeScript/HasQualifiedNameFallback/Test.ql index 2b63e171f1e9..199749ed3f60 100644 --- a/javascript/ql/test/library-tests/TypeScript/HasQualifiedNameFallback/Test.ql +++ b/javascript/ql/test/library-tests/TypeScript/HasQualifiedNameFallback/Test.ql @@ -1,13 +1,13 @@ import javascript -query TypeAnnotation hasQualifiedNameModule(string moduleName, string member) { - result.hasQualifiedName(moduleName, member) +query TypeAnnotation hasUnderlyingTypeModule(string moduleName, string member) { + result.hasUnderlyingType(moduleName, member) } -query TypeAnnotation hasQualifiedNameGlobal(string globalName) { - result.hasQualifiedName(globalName) +query TypeAnnotation hasUnderlyingTypeGlobal(string globalName) { + result.hasUnderlyingType(globalName) } query Parameter paramExample() { - result.getTypeAnnotation().hasQualifiedName("named-import", "Name1") + result.getTypeAnnotation().hasUnderlyingType("named-import", "Name1") } diff --git a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/HasUnderlyingType.expected b/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/HasUnderlyingType.expected deleted file mode 100644 index a9123b1ef55b..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/HasUnderlyingType.expected +++ /dev/null @@ -1,10 +0,0 @@ -#select -| foo.ts:3:12:3:12 | x | foo.Bar in unknown scope | -| foo.ts:4:10:4:10 | x | foo.Bar in unknown scope | -| tst.ts:8:14:8:16 | arg | Base in global scope | -| tst.ts:8:14:8:16 | arg | Sub in global scope | -underlyingTypeNode -| foo | | file://:0:0:0:0 | use moduleImport("foo").getMember("exports") | -| foo | | foo.ts:1:8:1:10 | use moduleImport("foo").getMember("exports").getMember("default") | -| foo | Bar | foo.ts:3:1:5:1 | use moduleImport("foo").getMember("exports").getMember("Bar").getInstance() | -| foo | Bar | foo.ts:3:12:3:12 | use moduleImport("foo").getMember("exports").getMember("Bar").getInstance() | diff --git a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/HasUnderlyingType.ql b/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/HasUnderlyingType.ql deleted file mode 100644 index 72d4e6d0f3d2..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/HasUnderlyingType.ql +++ /dev/null @@ -1,9 +0,0 @@ -import javascript - -from Expr e, TypeName typeName -where e.getType().hasUnderlyingTypeName(typeName) -select e, typeName - -query API::Node underlyingTypeNode(string mod, string name) { - result = API::Node::ofType(mod, name) -} diff --git a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/foo.ts b/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/foo.ts deleted file mode 100644 index 1b5be79068a8..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/foo.ts +++ /dev/null @@ -1,5 +0,0 @@ -import foo from "foo"; - -function f(x: foo.Bar) { - return x; -} diff --git a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/tsconfig.json deleted file mode 100644 index 4a2c2e629213..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/tsconfig.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "include": ["."] -} \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/tst.ts b/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/tst.ts deleted file mode 100644 index 02ca64296b5d..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/HasUnderlyingType/tst.ts +++ /dev/null @@ -1,9 +0,0 @@ -interface Base { - x: T; -} -interface Sub extends Base { - y: S; -} - -function foo(arg: (Sub & {w: number}) | string) { -} diff --git a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/TypeNames.expected b/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/TypeNames.expected deleted file mode 100644 index 3bca461afe29..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/TypeNames.expected +++ /dev/null @@ -1,22 +0,0 @@ -getTypeString -| bar/client.ts:9:23:9:27 | Inter | Inter | -| bar/client.ts:10:12:10:14 | Bar | Bar | -| foo/index.ts:2:10:2:12 | Bar | Bar | -| foo/index.ts:7:18:7:22 | Inter | Inter | -| foo/index.ts:8:10:8:12 | Bar | Bar | -importSpec -| false | bar/client.ts:1:10:1:12 | Foo | -| false | bar/client.ts:7:10:7:20 | Foo as Foo2 | -| true | bar/client.ts:7:23:7:32 | type Inter | -| true | bar/client.ts:7:35:7:42 | type Bar | -#select -| bar/client.ts:3:5:3:5 | f | my-awesome-package | Foo | -| bar/client.ts:3:9:3:17 | new Foo() | my-awesome-package | Foo | -| bar/client.ts:4:5:4:5 | b | my-awesome-package | Bar | -| bar/client.ts:4:9:4:9 | f | my-awesome-package | Foo | -| bar/client.ts:4:9:4:15 | f.bar() | my-awesome-package | Bar | -| bar/client.ts:11:16:11:24 | new Foo() | my-awesome-package | Foo | -| bar/client.ts:11:16:11:30 | new Foo().bar() | my-awesome-package | Bar | -| foo/index.ts:1:14:1:16 | Foo | my-awesome-package | Foo | -| foo/index.ts:2:23:2:31 | new Bar() | my-awesome-package | Bar | -| foo/index.ts:5:14:5:16 | Bar | my-awesome-package | Bar | diff --git a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/TypeNames.ql b/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/TypeNames.ql deleted file mode 100644 index 1db3ef62aede..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/TypeNames.ql +++ /dev/null @@ -1,11 +0,0 @@ -import javascript - -query string getTypeString(TypeExpr te) { result = te.getType().toString() } - -query ImportSpecifier importSpec(boolean typeOnly) { - if result.isTypeOnly() then typeOnly = true else typeOnly = false -} - -from Expr e, string mod, string name -where e.getType().(TypeReference).hasQualifiedName(mod, name) -select e, mod, name diff --git a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/bar/client.ts b/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/bar/client.ts deleted file mode 100644 index 6e5d88b412e5..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/bar/client.ts +++ /dev/null @@ -1,13 +0,0 @@ -import { Foo } from "../foo"; - -let f = new Foo(); -let b = f.bar(); - - -import { Foo as Foo2, type Inter, type Bar } from "../foo"; - -class Impl implements Inter { - bar(): Bar { - return new Foo().bar(); - } -} \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/foo/index.ts b/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/foo/index.ts deleted file mode 100644 index ee83e5fa92dc..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/foo/index.ts +++ /dev/null @@ -1,9 +0,0 @@ -export class Foo { - bar(): Bar { return new Bar() } -} - -export class Bar {} - -export interface Inter { - bar(): Bar; -} \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/foo/package.json b/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/foo/package.json deleted file mode 100644 index 0d82c265b2f4..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/foo/package.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "name": "my-awesome-package" -} diff --git a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/tsconfig.json deleted file mode 100644 index 850cac831e76..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/ImportOwnPackage/tsconfig.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "include": ["foo", "bar"] -} diff --git a/javascript/ql/test/library-tests/TypeScript/IndexTypes/test.expected b/javascript/ql/test/library-tests/TypeScript/IndexTypes/test.expected deleted file mode 100644 index 4779b178e4f6..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/IndexTypes/test.expected +++ /dev/null @@ -1,2 +0,0 @@ -| Foo | boolean | -| typeof Foo in global scope | string | diff --git a/javascript/ql/test/library-tests/TypeScript/IndexTypes/test.ql b/javascript/ql/test/library-tests/TypeScript/IndexTypes/test.ql deleted file mode 100644 index ff6a2a4836f4..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/IndexTypes/test.ql +++ /dev/null @@ -1,3 +0,0 @@ -import javascript - -query Type stringIndexType(Type t) { result = t.getStringIndexType() } diff --git a/javascript/ql/test/library-tests/TypeScript/IndexTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/IndexTypes/tsconfig.json deleted file mode 100644 index 9e26dfeeb6e6..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/IndexTypes/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{} \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/IndexTypes/tst.ts b/javascript/ql/test/library-tests/TypeScript/IndexTypes/tst.ts deleted file mode 100644 index 9035ff2b2acf..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/IndexTypes/tst.ts +++ /dev/null @@ -1,8 +0,0 @@ - // static index signature - class Foo { - static hello = "world"; - static [n: string]: string; - [n: string]: boolean; - } - Foo["whatever"] = "foo"; - new Foo()["something"] = true; \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/recursiveMappedType.ts b/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/recursiveMappedType.ts deleted file mode 100644 index a3a47ab49ad3..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/recursiveMappedType.ts +++ /dev/null @@ -1,8 +0,0 @@ -interface X { - a: RecursiveMappedType & X; - b: boolean; -} - -type RecursiveMappedType = { - [P in keyof V]?: X & RecursiveMappedType -} diff --git a/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/test.expected b/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/test.expected deleted file mode 100644 index 7a7033e01dd5..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/test.expected +++ /dev/null @@ -1,2 +0,0 @@ -| recursiveMappedType.ts:2:5:2:5 | a | RecursiveMappedType & X | -| recursiveMappedType.ts:3:5:3:5 | b | boolean | diff --git a/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/test.ql b/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/test.ql deleted file mode 100644 index 574b7c54d4ef..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/test.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from Expr e -select e, e.getType() diff --git a/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/tsconfig.json deleted file mode 100644 index d144c8ddb02c..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/InfiniteTypes/tsconfig.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "include": ["."] -} diff --git a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/TypeReferences.expected b/javascript/ql/test/library-tests/TypeScript/LexicalTypes/TypeReferences.expected deleted file mode 100644 index 4e6e39d9f47b..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/TypeReferences.expected +++ /dev/null @@ -1,16 +0,0 @@ -| C | 1 | bar.ts:10:10:10:24 | class C {} | -| C | 1 | foo.ts:10:10:10:24 | class C {} | -| C | 1 | bar.ts:10:10:10:24 | class C {} | -| C | 1 | foo.ts:10:10:10:24 | class C {} | -| ExportedClass | 1 | bar.ts:4:8:4:34 | class E ... Bar> {} | -| ExportedClass | 1 | foo.ts:4:8:4:34 | class E ... Foo> {} | -| ExportedClass | 1 | bar.ts:4:8:4:34 | class E ... Bar> {} | -| ExportedClass | 1 | foo.ts:4:8:4:34 | class E ... Foo> {} | -| InnerC | 1 | foo.ts:13:3:13:23 | class I ... oo1> {} | -| InnerC | 1 | foo.ts:18:3:18:23 | class I ... oo2> {} | -| InnerC | 1 | foo.ts:13:3:13:23 | class I ... oo1> {} | -| InnerC | 1 | foo.ts:18:3:18:23 | class I ... oo2> {} | -| LocalClass | 1 | bar.ts:3:1:3:24 | class L ... Bar> {} | -| LocalClass | 1 | foo.ts:3:1:3:24 | class L ... Foo> {} | -| LocalClass | 1 | bar.ts:3:1:3:24 | class L ... Bar> {} | -| LocalClass | 1 | foo.ts:3:1:3:24 | class L ... Foo> {} | diff --git a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/TypeReferences.ql b/javascript/ql/test/library-tests/TypeScript/LexicalTypes/TypeReferences.ql deleted file mode 100644 index 1609bba97f83..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/TypeReferences.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from TypeReference ref -select ref, count(ref.getADefinition()), ref.getADefinition() diff --git a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/bar.ts b/javascript/ql/test/library-tests/TypeScript/LexicalTypes/bar.ts deleted file mode 100644 index 7dcb2840feee..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/bar.ts +++ /dev/null @@ -1,12 +0,0 @@ -import * as dummy from "./dummy"; - -class LocalClass {} -export class ExportedClass {} - -let localBar = new LocalClass(); -let exportedBar = new ExportedClass(); - -namespace LocalNamespace { - export class C {} - let barC = new C(); -} diff --git a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/dummy.ts b/javascript/ql/test/library-tests/TypeScript/LexicalTypes/dummy.ts deleted file mode 100644 index c6f5ebf6678c..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/dummy.ts +++ /dev/null @@ -1 +0,0 @@ -export let x = 5; diff --git a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/foo.ts b/javascript/ql/test/library-tests/TypeScript/LexicalTypes/foo.ts deleted file mode 100644 index a8e24920d87e..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/foo.ts +++ /dev/null @@ -1,20 +0,0 @@ -import * as dummy from "./dummy"; - -class LocalClass {} -export class ExportedClass {} - -let localFoo = new LocalClass(); -let exportedFoo = new ExportedClass(); - -namespace LocalNamespace { - export class C {} - let fooC = new C(); - - class InnerC {} - let innerFoo1 = new InnerC(); -} - -namespace LocalNamespace { - class InnerC {} - let innerFoo2 = new InnerC(); -} diff --git a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/LexicalTypes/tsconfig.json deleted file mode 100644 index 0967ef424bce..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LexicalTypes/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{} diff --git a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/FloatLiteralTypes.expected b/javascript/ql/test/library-tests/TypeScript/LiteralTypes/FloatLiteralTypes.expected deleted file mode 100644 index 55f7be1ebe83..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/FloatLiteralTypes.expected +++ /dev/null @@ -1,4 +0,0 @@ -| 32 | 32.0 | -| 40.123 | 40.123 | -| 45 | 45.0 | -| 1099511627776 | 1.099511627776E12 | diff --git a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/FloatLiteralTypes.ql b/javascript/ql/test/library-tests/TypeScript/LiteralTypes/FloatLiteralTypes.ql deleted file mode 100644 index d503725ac286..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/FloatLiteralTypes.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from NumberLiteralType type -select type, type.getFloatValue() diff --git a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/IntLiteralTypes.expected b/javascript/ql/test/library-tests/TypeScript/LiteralTypes/IntLiteralTypes.expected deleted file mode 100644 index 6abc5f39062f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/IntLiteralTypes.expected +++ /dev/null @@ -1,2 +0,0 @@ -| 32 | 32 | -| 45 | 45 | diff --git a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/IntLiteralTypes.ql b/javascript/ql/test/library-tests/TypeScript/LiteralTypes/IntLiteralTypes.ql deleted file mode 100644 index 7012836516ea..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/IntLiteralTypes.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from NumberLiteralType type -select type, type.getIntValue() diff --git a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/LiteralTypes.expected b/javascript/ql/test/library-tests/TypeScript/LiteralTypes/LiteralTypes.expected deleted file mode 100644 index f0a26f408879..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/LiteralTypes.expected +++ /dev/null @@ -1,11 +0,0 @@ -| 32 | 32 | -| 40.123 | 40.123 | -| 45 | 45 | -| 1099511627776 | 1099511627776 | -| "31" | 31 | -| "" | | -| "A;B;C" | A;B;C | -| "dsfg" | dsfg | -| "sdfg" | sdfg | -| false | false | -| true | true | diff --git a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/LiteralTypes.ql b/javascript/ql/test/library-tests/TypeScript/LiteralTypes/LiteralTypes.ql deleted file mode 100644 index 7c491d90ef42..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/LiteralTypes.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from LiteralType type -select type, type.getStringValue() diff --git a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/LiteralTypes/tsconfig.json deleted file mode 100644 index d144c8ddb02c..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/tsconfig.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "include": ["."] -} diff --git a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/tst.ts b/javascript/ql/test/library-tests/TypeScript/LiteralTypes/tst.ts deleted file mode 100644 index ac75b4cf822f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/LiteralTypes/tst.ts +++ /dev/null @@ -1,12 +0,0 @@ -let intValue = 45; -let floatValue = 40.123; -let hexValue = 0x20; // 32 -let intWith40Bits = 1099511627776; -let stringValue = "dsfg"; -let stringValueType: "sdfg"; -let emptyStringType: "" = ""; -let semicolonString = "A;B;C"; -let numberStringValue = "31"; -let longStringValue = "very long string very long string very long string very long string very long string very long string very long string very long string very long string very long string"; -let trueValue = true; -let falseValue = false; diff --git a/javascript/ql/test/library-tests/TypeScript/NestedLiteral/test.expected b/javascript/ql/test/library-tests/TypeScript/NestedLiteral/test.expected deleted file mode 100644 index 2504915fb037..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/NestedLiteral/test.expected +++ /dev/null @@ -1,36 +0,0 @@ -| tst.ts:2:3:2:6 | name | string | -| tst.ts:3:3:3:10 | children | T[] | -| tst.ts:6:5:6:11 | context | T | -| tst.ts:6:18:17:1 | {\\n nam ... }\\n ]\\n} | T | -| tst.ts:7:3:7:6 | name | string | -| tst.ts:7:9:7:11 | 'x' | "x" | -| tst.ts:8:3:8:10 | children | ({ name: string; } \| { name: string; children: ... | -| tst.ts:8:13:16:3 | [\\n { ... }\\n ] | T[] | -| tst.ts:9:5:9:18 | { name: 'x1' } | T | -| tst.ts:9:7:9:10 | name | string | -| tst.ts:9:13:9:16 | 'x1' | "x1" | -| tst.ts:10:5:15:5 | {\\n ... ]\\n } | T | -| tst.ts:11:7:11:10 | name | string | -| tst.ts:11:13:11:16 | 'x2' | "x2" | -| tst.ts:12:7:12:14 | children | { name: string; }[] | -| tst.ts:12:17:14:7 | [\\n ... ] | T[] | -| tst.ts:13:9:13:22 | { name: 'x3' } | T | -| tst.ts:13:11:13:14 | name | string | -| tst.ts:13:17:13:20 | 'x3' | "x3" | -| tst.ts:19:5:19:13 | nocontext | { name: string; children: ({ name: string; chil... | -| tst.ts:19:17:30:1 | {\\n nam ... }\\n ]\\n} | { name: string; children: ({ name: string; } \| ... | -| tst.ts:20:3:20:6 | name | string | -| tst.ts:20:9:20:11 | 'x' | "x" | -| tst.ts:21:3:21:10 | children | ({ name: string; } \| { name: string; children: ... | -| tst.ts:21:13:29:3 | [\\n { ... }\\n ] | ({ name: string; } \| { name: string; children: ... | -| tst.ts:22:5:22:18 | { name: 'x1' } | { name: string; } | -| tst.ts:22:7:22:10 | name | string | -| tst.ts:22:13:22:16 | 'x1' | "x1" | -| tst.ts:23:5:28:5 | {\\n ... ]\\n } | { name: string; children: { name: string; }[]; } | -| tst.ts:24:7:24:10 | name | string | -| tst.ts:24:13:24:16 | 'x2' | "x2" | -| tst.ts:25:7:25:14 | children | { name: string; }[] | -| tst.ts:25:17:27:7 | [\\n ... ] | { name: string; }[] | -| tst.ts:26:9:26:22 | { name: 'x3' } | { name: string; } | -| tst.ts:26:11:26:14 | name | string | -| tst.ts:26:17:26:20 | 'x3' | "x3" | diff --git a/javascript/ql/test/library-tests/TypeScript/NestedLiteral/test.ql b/javascript/ql/test/library-tests/TypeScript/NestedLiteral/test.ql deleted file mode 100644 index 574b7c54d4ef..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/NestedLiteral/test.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from Expr e -select e, e.getType() diff --git a/javascript/ql/test/library-tests/TypeScript/NestedLiteral/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/NestedLiteral/tsconfig.json deleted file mode 100644 index a0565aca7581..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/NestedLiteral/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{ "include": ["."] } diff --git a/javascript/ql/test/library-tests/TypeScript/NestedLiteral/tst.ts b/javascript/ql/test/library-tests/TypeScript/NestedLiteral/tst.ts deleted file mode 100644 index 65515c62e945..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/NestedLiteral/tst.ts +++ /dev/null @@ -1,30 +0,0 @@ -interface T { - name: string; - children?: T[]; -} - -let context: T = { - name: 'x', - children: [ - { name: 'x1' }, - { - name: 'x2', - children: [ - { name: 'x3' } - ] - } - ] -} - -let nocontext = { - name: 'x', - children: [ - { name: 'x1' }, - { - name: 'x2', - children: [ - { name: 'x3' } - ] - } - ] -} diff --git a/javascript/ql/test/library-tests/TypeScript/Nullability/Types.expected b/javascript/ql/test/library-tests/TypeScript/Nullability/Types.expected deleted file mode 100644 index 6db617b3e77d..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Nullability/Types.expected +++ /dev/null @@ -1,10 +0,0 @@ -exprType -| tst.ts:1:5:1:16 | stringOrNUll | string \| null | -| tst.ts:2:5:2:21 | stringOrUndefined | string \| undefined | -| tst.ts:3:5:3:27 | stringO ... defined | string \| null \| undefined | -| tst.ts:4:5:4:16 | stringOrVoid | string \| void | -| tst.ts:7:5:7:21 | stringOrNullAlias | StringOrNullAlias | -| tst.ts:8:5:8:32 | stringO ... defined | string \| null \| undefined | -| tst.ts:10:5:10:23 | arrayOfStringOrNull | (string \| null)[] | -unaliasedType -| StringOrNullAlias | string \| null | diff --git a/javascript/ql/test/library-tests/TypeScript/Nullability/Types.ql b/javascript/ql/test/library-tests/TypeScript/Nullability/Types.ql deleted file mode 100644 index 0ca2bd6e15da..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Nullability/Types.ql +++ /dev/null @@ -1,5 +0,0 @@ -import javascript - -query Type exprType(Expr e) { result = e.getType() } - -query Type unaliasedType(TypeAliasReference ref) { result = ref.getAliasedType() } diff --git a/javascript/ql/test/library-tests/TypeScript/Nullability/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/Nullability/tsconfig.json deleted file mode 100644 index 6bb7671fa14c..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Nullability/tsconfig.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "include": ["."], - "compilerOptions": { - "strict": true - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/Nullability/tst.ts b/javascript/ql/test/library-tests/TypeScript/Nullability/tst.ts deleted file mode 100644 index f8ca1e565db7..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Nullability/tst.ts +++ /dev/null @@ -1,10 +0,0 @@ -let stringOrNUll: string | null; -let stringOrUndefined: string | undefined; -let stringOrNullOrUndefined: string | null | undefined; -let stringOrVoid: string | void; - -type StringOrNullAlias = string | null; -let stringOrNullAlias: StringOrNullAlias; -let stringOrNullAliasOrUndefined: StringOrNullAlias | undefined; - -let arrayOfStringOrNull: Array; diff --git a/javascript/ql/test/library-tests/TypeScript/PathMapping/Imports.expected b/javascript/ql/test/library-tests/TypeScript/PathMapping/Imports.expected deleted file mode 100644 index 886391b14552..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PathMapping/Imports.expected +++ /dev/null @@ -1,11 +0,0 @@ -symbols -| src/lib/foo.ts:1:1:4:0 | | src/lib/foo.ts | -| src/lib/foo.ts:1:8:3:1 | functio ... 123;\\n} | foo in src/lib/foo.ts | -| test/test_foo.ts:1:1:1:28 | import ... @/foo"; | src/lib/foo.ts | -| test/test_foo.ts:1:1:7:0 | | test/test_foo.ts | -| test/test_foo.ts:2:17:2:32 | require("@/foo") | src/lib/foo.ts | -| test/test_foo.ts:4:1:4:5 | foo() | foo in src/lib/foo.ts | -| test/test_foo.ts:6:1:6:12 | foolib.foo() | foo in src/lib/foo.ts | -#select -| test/test_foo.ts:1:1:1:28 | import ... @/foo"; | src/lib/foo.ts:1:1:4:0 | | -| test/test_foo.ts:2:17:2:32 | require("@/foo") | src/lib/foo.ts:1:1:4:0 | | diff --git a/javascript/ql/test/library-tests/TypeScript/PathMapping/Imports.ql b/javascript/ql/test/library-tests/TypeScript/PathMapping/Imports.ql deleted file mode 100644 index 8f93f6f37345..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PathMapping/Imports.ql +++ /dev/null @@ -1,6 +0,0 @@ -import javascript - -query predicate symbols(AstNode astNode, CanonicalName symbol) { ast_node_symbol(astNode, symbol) } - -from Import imprt -select imprt, imprt.getImportedModule() diff --git a/javascript/ql/test/library-tests/TypeScript/PathMapping/src/lib/foo.ts b/javascript/ql/test/library-tests/TypeScript/PathMapping/src/lib/foo.ts deleted file mode 100644 index 0ef2bf692fde..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PathMapping/src/lib/foo.ts +++ /dev/null @@ -1,3 +0,0 @@ -export function foo() { - return 123; -} diff --git a/javascript/ql/test/library-tests/TypeScript/PathMapping/test/test_foo.ts b/javascript/ql/test/library-tests/TypeScript/PathMapping/test/test_foo.ts deleted file mode 100644 index d30f56c53e70..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PathMapping/test/test_foo.ts +++ /dev/null @@ -1,6 +0,0 @@ -import { foo } from "@/foo"; -import foolib = require("@/foo"); - -foo(); - -foolib.foo(); diff --git a/javascript/ql/test/library-tests/TypeScript/PathMapping/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/PathMapping/tsconfig.json deleted file mode 100644 index 476d1ad1ee5d..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PathMapping/tsconfig.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "include": ["."], - "compilerOptions": { - "baseUrl": ".", - "paths": { - "@/*": ["./src/lib/*"] - } - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/DefinitelyTyped-LICENSE b/javascript/ql/test/library-tests/TypeScript/PromiseType/DefinitelyTyped-LICENSE deleted file mode 100644 index c3ee6e73d573..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/DefinitelyTyped-LICENSE +++ /dev/null @@ -1,8 +0,0 @@ -This project is licensed under the MIT license. -Copyrights are respective of each contributor listed at the beginning of each definition file. - -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/PromiseType.expected b/javascript/ql/test/library-tests/TypeScript/PromiseType/PromiseType.expected deleted file mode 100644 index 40c1f30e72a3..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/PromiseType.expected +++ /dev/null @@ -1,9 +0,0 @@ -| p1 | MyPromise | string | -| p2 | MyPromise | any | -| p3 | Promise | string | -| p5 | PromiseLike | string | -| p6 | Thenable | string | -| p8 | ThenPromise | string | -| p9 | JQueryPromise | string | -| p10 | JQueryGenericPromise | string | -| p11 | JQueryDeferred | string | diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/PromiseType.ql b/javascript/ql/test/library-tests/TypeScript/PromiseType/PromiseType.ql deleted file mode 100644 index 477c4dc888fb..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/PromiseType.ql +++ /dev/null @@ -1,12 +0,0 @@ -import javascript - -string getElementType(PromiseType t) { - result = t.getElementType().toString() - or - not exists(t.getElementType().toString()) and - result = "" -} - -from VarDecl decl, PromiseType type -where type = decl.getTypeAnnotation().getType() -select decl.getName(), type, getElementType(type) diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/QDeferred.expected b/javascript/ql/test/library-tests/TypeScript/PromiseType/QDeferred.expected deleted file mode 100644 index b3567dfe8d36..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/QDeferred.expected +++ /dev/null @@ -1 +0,0 @@ -| tst.ts:33:5:33:15 | notPromise4 | diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/QDeferred.ql b/javascript/ql/test/library-tests/TypeScript/PromiseType/QDeferred.ql deleted file mode 100644 index 7d11a5e5dcd3..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/QDeferred.ql +++ /dev/null @@ -1,5 +0,0 @@ -import javascript - -from Expr e -where e.getType().hasUnderlyingType("q", "Deferred") -select e diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/es6-promise-LICENSE b/javascript/ql/test/library-tests/TypeScript/PromiseType/es6-promise-LICENSE deleted file mode 100644 index 954ec5992df7..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/es6-promise-LICENSE +++ /dev/null @@ -1,19 +0,0 @@ -Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/es6-promise.d.ts b/javascript/ql/test/library-tests/TypeScript/PromiseType/es6-promise.d.ts deleted file mode 100644 index 815584496e89..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/es6-promise.d.ts +++ /dev/null @@ -1,9 +0,0 @@ -// Based on the .d.ts file from the '@types/es6-promise' package (https://github.com/stefanpenner/es6-promise/blob/master/es6-promise.d.ts), -// licensed under the MIT license; see file es6-promise-LICENSE. - -export interface Thenable { - then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => U | Thenable): Thenable; - then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => void): Thenable; -} - -export type IThenable = Thenable; diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/jquery.d.ts b/javascript/ql/test/library-tests/TypeScript/PromiseType/jquery.d.ts deleted file mode 100644 index 4bde0e5ffef7..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/jquery.d.ts +++ /dev/null @@ -1,41 +0,0 @@ -// Based on the .d.ts file from the '@types/jquery' package (https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/jquery/index.d.ts), -// which is licensed under the MIT license; see file DefinitelyTyped-LICENSE. -// Type definitions for jquery 3.3 -// Project: https://jquery.com -// Definitions by: Leonard Thieu -// Boris Yankov -// Christian Hoffmeister -// Steve Fenton -// Diullei Gomes -// Tass Iliopoulos -// Jason Swearingen -// Sean Hill -// Guus Goossens -// Kelly Summerlin -// Basarat Ali Syed -// Nicholas Wolverson -// Derek Cicerone -// Andrew Gaspar -// Seikichi Kondo -// Benjamin Jackman -// Poul Sorensen -// Josh Strobl -// John Reilly -// Dick van den Brink -// Thomas Schulz -// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped -// TypeScript Version: 2.3 - -interface JQueryGenericPromise { - then(doneFilter: (value?: T, ...values: any[]) => U|JQueryPromise, failFilter?: (...reasons: any[]) => any, progressFilter?: (...progression: any[]) => any): JQueryPromise; - then(doneFilter: (value?: T, ...values: any[]) => void, failFilter?: (...reasons: any[]) => any, progressFilter?: (...progression: any[]) => any): JQueryPromise; -} - -interface JQueryPromise extends JQueryGenericPromise { - state(): string; - promise(target?: any): JQueryPromise; -} - -interface JQueryDeferred extends JQueryGenericPromise { - notify(value?: any, ...args: any[]): JQueryDeferred; -} diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/node_modules/@types/q/index.d.ts b/javascript/ql/test/library-tests/TypeScript/PromiseType/node_modules/@types/q/index.d.ts deleted file mode 100644 index de520c5faa5e..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/node_modules/@types/q/index.d.ts +++ /dev/null @@ -1,27 +0,0 @@ -// Based on the .d.ts file from the '@types/q' package (https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/q/index.d.ts) -// which is licensed under the MIT license; see file DefinitelyTyped-LICENSE. -// Type definitions for Q 1.5 -// Project: https://github.com/kriskowal/q -// Definitions by: Barrie Nemetchek -// Andrew Gaspar -// John Reilly -// Michel Boudreau -// TeamworkGuy2 -// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped -// TypeScript Version: 2.3 - -export = Q; - -declare namespace Q { - export type IWhenable = PromiseLike | T; - export type IPromise = PromiseLike; - - export interface Deferred { - promise: Promise; - resolve(value?: IWhenable): void; - } - - export interface Promise { - then(onFulfill?: ((value: T) => IWhenable) | null, onReject?: ((error: any) => IWhenable) | null, onProgress?: ((progress: any) => any) | null): Promise; - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/promise-LICENSE b/javascript/ql/test/library-tests/TypeScript/PromiseType/promise-LICENSE deleted file mode 100644 index 7a1f763640a9..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/promise-LICENSE +++ /dev/null @@ -1,19 +0,0 @@ -Copyright (c) 2014 Forbes Lindesay - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/promise.d.ts b/javascript/ql/test/library-tests/TypeScript/PromiseType/promise.d.ts deleted file mode 100644 index 85aec3783fea..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/promise.d.ts +++ /dev/null @@ -1,11 +0,0 @@ -// Based on the .d.ts file from the 'promise' package (https://github.com/then/promise/blob/master/index.d.ts), -// which is licensed under the MIT license; see file promise-LICENSE. - -export interface Thenable { - then(onfulfilled?: ((value: T) => TResult1 | Thenable) | undefined | null, onrejected?: ((reason: any) => TResult2 | Thenable) | undefined | null): Thenable; -} - -export interface ThenPromise { - then(onfulfilled?: ((value: T) => TResult1 | Thenable) | undefined | null, onrejected?: ((reason: any) => TResult2 | Thenable) | undefined | null): ThenPromise; - catch(onrejected?: ((reason: any) => TResult | Thenable) | undefined | null): ThenPromise; -} diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/PromiseType/tsconfig.json deleted file mode 100644 index 4a2c2e629213..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/tsconfig.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "include": ["."] -} \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/PromiseType/tst.ts b/javascript/ql/test/library-tests/TypeScript/PromiseType/tst.ts deleted file mode 100644 index 1600caf88f4d..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/PromiseType/tst.ts +++ /dev/null @@ -1,34 +0,0 @@ -import * as Q from "q"; -import { Thenable, IThenable } from "./es6-promise"; -import * as promise from "./promise"; - -interface MyPromise { - then(callback: (x: T) => any): MyPromise; -} - -let p1: MyPromise; -let p2: MyPromise; -let p3: Promise; -let p4: Q.IPromise; -let p5: PromiseLike; -let p6: Thenable; -let p7: IThenable; -let p8: promise.ThenPromise; -let p9: JQueryPromise; -let p10: JQueryGenericPromise; -let p11: JQueryDeferred; - -interface NotPromise { - then(x: T): T; -} -interface WrongName { - then(callback: (x:T) => any): WrongName; -} -interface StringPromise { - then(callback: (x: string) => any): StringPromise; -} -let notPromise1: NotPromise; -let notPromise2: WrongName; -let notPromise3: StringPromise; -let notPromise4: Q.Deferred; // different API - lacks 'then' method - diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/Namespaces.expected b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/Namespaces.expected deleted file mode 100644 index 0494011bc70a..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/Namespaces.expected +++ /dev/null @@ -1,33 +0,0 @@ -| A in enums.ts | -| A in export-qualified.ts | -| A in namespaces.ts | -| A.B in export-qualified.ts | -| A.C in namespaces.ts | -| A.E in enums.ts | -| B in namespaces.ts:3 | -| B in namespaces.ts:10 | -| B.Bx in namespaces.ts:3 | -| B.Bx in namespaces.ts:10 | -| D in export-specifiers.ts | -| D in namespaces.ts | -| D in otherlib.ts | -| D.F in namespaces.ts | -| E in namespaces.ts:17 | -| E in namespaces.ts:22 | -| Foo in global scope | -| G in namespaces.ts | -| G.J in namespaces.ts | -| Glob in global scope | -| H in namespaces.ts:27 | -| H.I in namespaces.ts:27 | -| N in export-specifiers.ts | -| X in global scope | -| X in namespaces.ts | -| X.Y in namespaces.ts | -| X.Y.Z in namespaces.ts | -| Y in global scope | -| export-class.ts | -| namespaces.ts | -| otherlib.ts | -| reexport-all.ts | -| reexport-named.ts | diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/Namespaces.ql b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/Namespaces.ql deleted file mode 100644 index a7f5c980cccb..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/Namespaces.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from Namespace namespace -select namespace.toString() diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveNamespace.expected b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveNamespace.expected deleted file mode 100644 index 7ec8faec19ff..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveNamespace.expected +++ /dev/null @@ -1,31 +0,0 @@ -| ambient.ts:5:16:5:18 | Foo | Foo in global scope | -| enums.ts:9:8:9:8 | A | A in enums.ts | -| enums.ts:9:8:9:10 | A.E | A.E in enums.ts | -| enums.ts:10:8:10:8 | A | A in enums.ts | -| export-qualified-client.ts:3:8:3:9 | AB | A.B in export-qualified.ts | -| export-specifiers-client.ts:4:8:4:8 | N | N in export-specifiers.ts | -| export-specifiers-client.ts:5:8:5:8 | D | D in export-specifiers.ts | -| global.ts:5:9:5:12 | Glob | Glob in global scope | -| import-in-namespace.ts:9:13:9:13 | A | X in global scope | -| namespaces-client.ts:4:9:4:10 | ns | namespaces.ts | -| namespaces-client.ts:4:9:4:12 | ns.G | G in namespaces.ts | -| namespaces-client.ts:5:9:5:9 | G | G in namespaces.ts | -| namespaces-client.ts:6:9:6:9 | G | G in namespaces.ts | -| namespaces-client.ts:6:9:6:11 | G.J | G.J in namespaces.ts | -| reexport-all-client.ts:4:9:4:10 | ns | reexport-all.ts | -| reexport-all-client.ts:4:9:4:12 | ns.G | G in namespaces.ts | -| reexport-all-client.ts:5:9:5:9 | G | G in namespaces.ts | -| reexport-all-client.ts:6:9:6:9 | G | G in namespaces.ts | -| reexport-all-client.ts:6:9:6:11 | G.J | G.J in namespaces.ts | -| reexport-all-client.ts:8:8:8:8 | D | D in otherlib.ts | -| reexport-all-client.ts:9:8:9:9 | ns | reexport-all.ts | -| reexport-all-client.ts:9:8:9:11 | ns.D | D in otherlib.ts | -| reexport-all-client.ts:11:8:11:9 | ns | reexport-all.ts | -| reexport-named-client.ts:4:9:4:10 | ns | reexport-named.ts | -| reexport-named-client.ts:4:9:4:12 | ns.G | G in namespaces.ts | -| reexport-named-client.ts:5:9:5:9 | G | G in namespaces.ts | -| reexport-named-client.ts:6:9:6:9 | G | G in namespaces.ts | -| reexport-named-client.ts:6:9:6:11 | G.J | G.J in namespaces.ts | -| reexport-named-client.ts:8:8:8:8 | X | D in namespaces.ts | -| reexport-named-client.ts:9:8:9:9 | ns | reexport-named.ts | -| reexport-named-client.ts:9:8:9:11 | ns.X | D in namespaces.ts | diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveNamespace.ql b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveNamespace.ql deleted file mode 100644 index 3009390546bd..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveNamespace.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from NamespaceAccess access -select access, access.getNamespace().toString() diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveTypeName.expected b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveTypeName.expected deleted file mode 100644 index 1629bdac5b15..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveTypeName.expected +++ /dev/null @@ -1,27 +0,0 @@ -| ambient.ts:5:16:5:20 | Foo.C | Foo.C in global scope | -| enums.ts:9:8:9:12 | A.E.x | A.E.x in enums.ts | -| enums.ts:10:8:10:10 | A.E | A.E in enums.ts | -| export-class-client-renamed.ts:3:8:3:8 | X | Banana in export-class.ts | -| export-class-client.ts:3:8:3:13 | Banana | Banana in export-class.ts | -| export-qualified-client.ts:3:8:3:11 | AB.C | A.B.C in export-qualified.ts | -| export-specifiers-client.ts:4:8:4:10 | N.C | N.C in export-specifiers.ts | -| export-specifiers-client.ts:5:8:5:10 | D.C | D.C in export-specifiers.ts | -| export-specifiers-client.ts:6:8:6:8 | C | C in export-specifiers.ts | -| global.ts:5:9:5:14 | Glob.C | Glob.C in global scope | -| import-in-namespace.ts:9:13:9:15 | A.C | X.C in global scope | -| import-in-namespace.ts:10:13:10:13 | D | X.C in global scope | -| namespaces-client.ts:4:9:4:14 | ns.G.C | G.C in namespaces.ts | -| namespaces-client.ts:5:9:5:11 | G.C | G.C in namespaces.ts | -| namespaces-client.ts:6:9:6:13 | G.J.C | G.J.C in namespaces.ts | -| reexport-all-client.ts:4:9:4:14 | ns.G.C | G.C in namespaces.ts | -| reexport-all-client.ts:5:9:5:11 | G.C | G.C in namespaces.ts | -| reexport-all-client.ts:6:9:6:13 | G.J.C | G.J.C in namespaces.ts | -| reexport-all-client.ts:8:8:8:10 | D.F | D.F in unknown scope | -| reexport-all-client.ts:9:8:9:13 | ns.D.F | ns.D.F in unknown scope | -| reexport-all-client.ts:11:8:11:16 | ns.Banana | Banana in export-class.ts | -| reexport-named-client.ts:4:9:4:14 | ns.G.C | G.C in namespaces.ts | -| reexport-named-client.ts:5:9:5:11 | G.C | G.C in namespaces.ts | -| reexport-named-client.ts:6:9:6:13 | G.J.C | G.J.C in namespaces.ts | -| reexport-named-client.ts:8:8:8:10 | X.F | X.F in unknown scope | -| reexport-named-client.ts:9:8:9:13 | ns.X.F | ns.X.F in unknown scope | -| reexport-named-client.ts:11:9:11:9 | Y | Banana in export-class.ts | diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveTypeName.ql b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveTypeName.ql deleted file mode 100644 index 0960b3043863..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ResolveTypeName.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from TypeAccess access -select access, access.getTypeName().toString() diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ambient.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ambient.ts deleted file mode 100644 index 0d4eaacd18f8..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/ambient.ts +++ /dev/null @@ -1,5 +0,0 @@ -declare namespace Foo { - class C {} -} - -declare var x: Foo.C; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/dummy.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/dummy.ts deleted file mode 100644 index 089c0a05a539..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/dummy.ts +++ /dev/null @@ -1 +0,0 @@ -export var X = 5; \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/enums.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/enums.ts deleted file mode 100644 index b7a66b0b3cca..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/enums.ts +++ /dev/null @@ -1,10 +0,0 @@ -import * as dummylib from './dummy'; // ensure file is treated as a module - -namespace A { - export enum E { - x, y - } -} - -var x: A.E.x; -var y: A.E; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-class-client-renamed.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-class-client-renamed.ts deleted file mode 100644 index 2ed89259ea04..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-class-client-renamed.ts +++ /dev/null @@ -1,3 +0,0 @@ -import {Banana as X} from './export-class'; - -var x: X; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-class-client.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-class-client.ts deleted file mode 100644 index 52d327402242..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-class-client.ts +++ /dev/null @@ -1,3 +0,0 @@ -import {Banana} from './export-class'; - -var x: Banana; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-class.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-class.ts deleted file mode 100644 index 3e2fe9842823..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-class.ts +++ /dev/null @@ -1,3 +0,0 @@ -import * as dummylib from './dummy'; // ensure file is treated as a module - -export class Banana {} diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-default-type-client.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-default-type-client.ts deleted file mode 100644 index cfdec84c1254..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-default-type-client.ts +++ /dev/null @@ -1,3 +0,0 @@ -import T from './export-default-type-client'; - -var x: T; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-default-type.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-default-type.ts deleted file mode 100644 index 6313e8c0d160..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-default-type.ts +++ /dev/null @@ -1,5 +0,0 @@ -import * as dummylib from './dummy'; // ensure file is treated as a module - -class C {} - -export default C; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-qualified-client.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-qualified-client.ts deleted file mode 100644 index 1d39e3ef3ccb..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-qualified-client.ts +++ /dev/null @@ -1,3 +0,0 @@ -import AB from './export-qualified'; - -var x: AB.C; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-qualified.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-qualified.ts deleted file mode 100644 index 237131fbebd1..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-qualified.ts +++ /dev/null @@ -1,7 +0,0 @@ -import * as dummylib from './dummy'; // ensure file is treated as a module - -namespace A.B { - export class C {} -} - -export default A.B; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-specifiers-client.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-specifiers-client.ts deleted file mode 100644 index 937efff9e3ed..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-specifiers-client.ts +++ /dev/null @@ -1,6 +0,0 @@ -import {N, C} from './export-specifiers'; -import D from './export-specifiers'; - -var x: N.C; -var y: D.C; -var z: C; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-specifiers.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-specifiers.ts deleted file mode 100644 index ad0a6f5da59f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/export-specifiers.ts +++ /dev/null @@ -1,13 +0,0 @@ -import * as dummylib from './dummy'; // ensure file is treated as a module - -namespace N { - export class C {} -} -namespace D { - export class C {} -} - -class C {} - -export {N, C}; -export default D; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/global.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/global.ts deleted file mode 100644 index 6ee6dbbd5afb..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/global.ts +++ /dev/null @@ -1,5 +0,0 @@ -namespace Glob { - export class C {} -} - -var x : Glob.C; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/import-in-namespace.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/import-in-namespace.ts deleted file mode 100644 index 17ad81aae9cd..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/import-in-namespace.ts +++ /dev/null @@ -1,11 +0,0 @@ -namespace X { - export class C {} -} - -namespace Y { - import A = X; - import D = X.C; - - var foo : A.C; - var bar : D; -} diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/namespaces-client.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/namespaces-client.ts deleted file mode 100644 index 3ee30fb0abcb..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/namespaces-client.ts +++ /dev/null @@ -1,6 +0,0 @@ -import * as ns from './namespaces' -import {G} from './namespaces' - -var x : ns.G.C; -var y : G.C; -var z : G.J.C; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/namespaces.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/namespaces.ts deleted file mode 100644 index 10530e5789d3..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/namespaces.ts +++ /dev/null @@ -1,43 +0,0 @@ -import * as dummylib from './dummy'; // ensure file is treated as a module - -namespace A { - namespace B { - export namespace Bx {} - } - export namespace C {;} -} - -namespace A { - namespace B { // distinct from previous `B` - export namespace Bx {} // distinct from previous `Bx` - } - export namespace C {;} // same as previous `C` -} - -export namespace D { - namespace E {;} - export namespace F {;} -} - -export namespace D { - namespace E {;} // distinct from previous `E` - export namespace F {;} // same as previous `F` -} - -export namespace G { - namespace H { - export namespace I {} - } - namespace H { // same as previous `H` - export namespace I {} // same as previous `I` - } - export class C {} - export namespace J { - export class C {} - } -} - -namespace X.Y.Z {;} -namespace X { - export namespace Y.Z {;} -} diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/otherlib.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/otherlib.ts deleted file mode 100644 index 3d11847269a0..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/otherlib.ts +++ /dev/null @@ -1 +0,0 @@ -export namespace D {;} diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-all-client.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-all-client.ts deleted file mode 100644 index c94b2a0f6fe6..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-all-client.ts +++ /dev/null @@ -1,11 +0,0 @@ -import * as ns from './reexport-all' -import {G, D} from './reexport-all' - -var x : ns.G.C; -var y : G.C; -var z : G.J.C; - -var u: D.F; -var v: ns.D.F; - -var b: ns.Banana; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-all.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-all.ts deleted file mode 100644 index 314919e92e29..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-all.ts +++ /dev/null @@ -1,3 +0,0 @@ -export * from './namespaces'; -export * from './export-class'; -export {D} from './otherlib'; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-named-client.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-named-client.ts deleted file mode 100644 index 1b33aa5aec0d..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-named-client.ts +++ /dev/null @@ -1,11 +0,0 @@ -import * as ns from './reexport-named' -import {G, X, Y} from './reexport-named' - -var x : ns.G.C; -var y : G.C; -var z : G.J.C; - -var u: X.F; -var v: ns.X.F; - -var bn: Y diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-named.ts b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-named.ts deleted file mode 100644 index 3398c598c6f0..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/reexport-named.ts +++ /dev/null @@ -1,2 +0,0 @@ -export {G, D as X} from './namespaces'; -export {Banana as Y} from './export-class'; diff --git a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/tsconfig.json deleted file mode 100644 index 9e26dfeeb6e6..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/QualifiedNameResolution/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{} \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/main.ts b/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/main.ts deleted file mode 100644 index b512cdbf8aec..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/main.ts +++ /dev/null @@ -1,2 +0,0 @@ -import f = require("./tst"); -f("world"); diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/test.expected b/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/test.expected deleted file mode 100644 index f54412aae1ba..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/test.expected +++ /dev/null @@ -1,5 +0,0 @@ -| main.ts:1:8:1:8 | f | (x: string) => string | -| main.ts:1:20:1:26 | "./tst" | any | -| main.ts:2:1:2:1 | f | (x: string) => string | -| main.ts:2:1:2:10 | f("world") | string | -| main.ts:2:3:2:9 | "world" | "world" | diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/test.ql b/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/test.ql deleted file mode 100644 index 574b7c54d4ef..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/test.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from Expr e -select e, e.getType() diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/tsconfig.json deleted file mode 100644 index da105dfc1937..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/tsconfig.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "compilerOptions": { - "allowJs": true - }, - "include": ["."] -} diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/tst.js b/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/tst.js deleted file mode 100644 index 73496edb942b..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/AllowJs/tst.js +++ /dev/null @@ -1,6 +0,0 @@ -/** - * @param {String} x - */ -module.exports = function(x) { - return 'Hello ' + x; -} diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/EmptyName/test.expected b/javascript/ql/test/library-tests/TypeScript/RegressionTests/EmptyName/test.expected index 85cb86df42a2..6c41a8ed4625 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/EmptyName/test.expected +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/EmptyName/test.expected @@ -1,4 +1 @@ -| MK in unknown scope | -| Mapped in test.ts | -| fn in test.ts | -| test.ts | +| Just test extraction | diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/EmptyName/test.ql b/javascript/ql/test/library-tests/TypeScript/RegressionTests/EmptyName/test.ql index 3212e219ccd1..75d972c7ba1f 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/EmptyName/test.ql +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/EmptyName/test.ql @@ -1,4 +1,3 @@ import javascript -from CanonicalName name -select name +select "Just test extraction" diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/ExportEqualsExpr/test.expected b/javascript/ql/test/library-tests/TypeScript/RegressionTests/ExportEqualsExpr/test.expected index 24fc12058753..6c41a8ed4625 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/ExportEqualsExpr/test.expected +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/ExportEqualsExpr/test.expected @@ -1,7 +1 @@ -| "bar" in global scope | -| C in module 'bar' | -| Foo in global scope | -| Foo in tst.ts | -| module 'bar' | -| module 'foo' | -| tst.ts | +| Just test extraction | diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/ExportEqualsExpr/test.ql b/javascript/ql/test/library-tests/TypeScript/RegressionTests/ExportEqualsExpr/test.ql index 3212e219ccd1..75d972c7ba1f 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/ExportEqualsExpr/test.ql +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/ExportEqualsExpr/test.ql @@ -1,4 +1,3 @@ import javascript -from CanonicalName name -select name +select "Just test extraction" diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/test.expected b/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/test.expected deleted file mode 100644 index 0be0c0ae2510..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/test.expected +++ /dev/null @@ -1,15 +0,0 @@ -typeAliases -| tst.ts:1:8:1:41 | type Fo ... R \| A>; | -| tst.ts:3:8:3:42 | type Ba ... R, A]>; | -| tst.ts:5:8:5:47 | type Ba ... => A>; | -typeAliasType -| tst.ts:1:8:1:41 | type Fo ... R \| A>; | Foo | -| tst.ts:3:8:3:42 | type Ba ... R, A]>; | Bar | -| tst.ts:5:8:5:47 | type Ba ... => A>; | Baz | -getAliasedType -| Bar | () => Bar<[R, A]> | -| Bar<[R, A]> | () => Bar<[[R, A], A]> | -| Baz<(x: R) => A> | () => Baz<(x: (x: R) => A) => A> | -| Baz | () => Baz<(x: R) => A> | -| Foo | () => Foo | -| Foo | () => Foo | diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/test.ql b/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/test.ql deleted file mode 100644 index 5fa86781b95e..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/test.ql +++ /dev/null @@ -1,8 +0,0 @@ -import javascript - -// The extractor would hang on this test case, it doesn't matter too much what the output of the test is. -query TypeAliasDeclaration typeAliases() { any() } - -query Type typeAliasType(TypeAliasDeclaration decl) { result = decl.getTypeName().getType() } - -query Type getAliasedType(TypeAliasReference ref) { result = ref.getAliasedType() } diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/tst.ts b/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/tst.ts deleted file mode 100644 index 92f63a28b967..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/tst.ts +++ /dev/null @@ -1,5 +0,0 @@ -export type Foo = () => Foo; - -export type Bar = () => Bar<[R, A]>; - -export type Baz = () => Baz<(x: R) => A>; diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/ImportSelf/test.expected b/javascript/ql/test/library-tests/TypeScript/RegressionTests/ImportSelf/test.expected index 756178b48073..6c41a8ed4625 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/ImportSelf/test.expected +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/ImportSelf/test.expected @@ -1,3 +1 @@ -| bar.ts:1:10:1:10 | A | any | -| bar.ts:1:19:1:29 | "@blah/foo" | any | -| bar.ts:3:5:3:5 | x | A | +| Just test extraction | diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/ImportSelf/test.ql b/javascript/ql/test/library-tests/TypeScript/RegressionTests/ImportSelf/test.ql index d194e75f71ad..75d972c7ba1f 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/ImportSelf/test.ql +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/ImportSelf/test.ql @@ -1,5 +1,3 @@ import javascript -// We're mainly testing extraction succeeds, so just test that some types are extracted. -from Expr e -select e, e.getType() +select "Just test extraction" diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/RecursiveTypeAlias/Test.expected b/javascript/ql/test/library-tests/TypeScript/RegressionTests/RecursiveTypeAlias/Test.expected index e69de29bb2d1..6c41a8ed4625 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/RecursiveTypeAlias/Test.expected +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/RecursiveTypeAlias/Test.expected @@ -0,0 +1 @@ +| Just test extraction | diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/RecursiveTypeAlias/Test.ql b/javascript/ql/test/library-tests/TypeScript/RegressionTests/RecursiveTypeAlias/Test.ql index 1d9bf4c9aae4..75d972c7ba1f 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/RecursiveTypeAlias/Test.ql +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/RecursiveTypeAlias/Test.ql @@ -1,4 +1,3 @@ import javascript -from TypeAliasDeclaration decl -select decl, decl.getDefinition().getType() +select "Just test extraction" diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/SemicolonInName/test.expected b/javascript/ql/test/library-tests/TypeScript/RegressionTests/SemicolonInName/test.expected index 603eaba0d279..6c41a8ed4625 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/SemicolonInName/test.expected +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/SemicolonInName/test.expected @@ -1,2 +1 @@ -| Bar.Foo in global scope | Bar in global scope | -| fn in test.ts | test.ts | +| Just test extraction | diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/SemicolonInName/test.ql b/javascript/ql/test/library-tests/TypeScript/RegressionTests/SemicolonInName/test.ql index b722f0aa2d68..75d972c7ba1f 100644 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/SemicolonInName/test.ql +++ b/javascript/ql/test/library-tests/TypeScript/RegressionTests/SemicolonInName/test.ql @@ -1,4 +1,3 @@ import javascript -from CanonicalName typename -select typename, typename.getParent() +select "Just test extraction" diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/node_modules/@types/foo/index.d.ts b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/node_modules/@types/foo/index.d.ts deleted file mode 100644 index 2a567fce490c..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/node_modules/@types/foo/index.d.ts +++ /dev/null @@ -1 +0,0 @@ -export function foo(); diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/test.expected b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/test.expected deleted file mode 100644 index bab38be1e231..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/test.expected +++ /dev/null @@ -1,4 +0,0 @@ -| test.ts:1:10:1:12 | foo | () => any | -| test.ts:1:21:1:25 | "foo" | any | -| test.ts:3:1:3:3 | foo | () => any | -| test.ts:3:1:3:5 | foo() | any | diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/test.ql b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/test.ql deleted file mode 100644 index 574b7c54d4ef..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/test.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from Expr e -select e, e.getType() diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/test.ts b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/test.ts deleted file mode 100644 index c888001b9817..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/test.ts +++ /dev/null @@ -1,3 +0,0 @@ -import { foo } from "foo"; - -foo(); diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/tsconfig.json deleted file mode 100644 index fa0f06c0ad8f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TraceResolution/tsconfig.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "include": ["."], - "compilerOptions": { - "traceResolution": true - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/test.expected b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/test.expected deleted file mode 100644 index 840934a14d38..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/test.expected +++ /dev/null @@ -1,3 +0,0 @@ -| tsconfig.json:0:0:0:0 | tsconfig.json | -| tst.ts:0:0:0:0 | tst.ts | -| typeroot.d.ts:0:0:0:0 | typeroot.d.ts | diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/test.ql b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/test.ql deleted file mode 100644 index c014228798bb..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/test.ql +++ /dev/null @@ -1,4 +0,0 @@ -import javascript - -from File file -select file diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/tsconfig.json deleted file mode 100644 index cfce6655fd75..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/tsconfig.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "include": ["."], - "compilerOptions": { - "typeRoots": ["typeroot.d.ts"] - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/tst.ts b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/tst.ts deleted file mode 100644 index 72a84dc0cde2..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/tst.ts +++ /dev/null @@ -1 +0,0 @@ -let x = 5; \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/typeroot.d.ts b/javascript/ql/test/library-tests/TypeScript/RegressionTests/TypeRootFile/typeroot.d.ts deleted file mode 100644 index e69de29bb2d1..000000000000 diff --git a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/src/main.ts b/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/src/main.ts deleted file mode 100644 index 403c78e0d0d5..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/src/main.ts +++ /dev/null @@ -1,4 +0,0 @@ -export function main(foo: string) { - let x = foo; - console.log(x); -} diff --git a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/test.expected b/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/test.expected deleted file mode 100644 index 47ea4115ae61..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/test.expected +++ /dev/null @@ -1,11 +0,0 @@ -types -| (...data: any[]) => void | -| (foo: string) => void | -| Console | -| any | -| any[] | -| string | -| void | -jsonFiles -| tsconfig.foo.json:0:0:0:0 | tsconfig.foo.json | -| tsconfig.json:0:0:0:0 | tsconfig.json | diff --git a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/test.ql b/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/test.ql deleted file mode 100644 index 25ace33c8a38..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/test.ql +++ /dev/null @@ -1,5 +0,0 @@ -import javascript - -query predicate types(Type type) { any() } - -query predicate jsonFiles(File file) { file.getExtension() = "json" } diff --git a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/tsconfig.foo.json b/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/tsconfig.foo.json deleted file mode 100644 index 658aef62ac0e..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/tsconfig.foo.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "extends": "./tsconfig.json", - "include": [ - "src" - ], - "compilerOptions": { - "composite": true - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/tsconfig.json deleted file mode 100644 index b0f85a63f5f2..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/TSConfigReferences/tsconfig.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "include": [], - "files": [], - "references": [ - { "path": "./tsconfig.foo.json" }, - ], -} diff --git a/javascript/ql/test/library-tests/TypeScript/TypeAliases/TypeAliases.expected b/javascript/ql/test/library-tests/TypeScript/TypeAliases/TypeAliases.expected index 061c2e241bce..7d3bd949b9ed 100644 --- a/javascript/ql/test/library-tests/TypeScript/TypeAliases/TypeAliases.expected +++ b/javascript/ql/test/library-tests/TypeScript/TypeAliases/TypeAliases.expected @@ -1,4 +1,3 @@ -#select | tst.ts:1:1:1:16 | type A = number; | tst.ts:1:6:1:6 | A | 0 | tst.ts:1:10:1:15 | number | | tst.ts:2:1:2:16 | type B = T[]; | tst.ts:2:6:2:6 | B | 1 | tst.ts:2:13:2:15 | T[] | | tst.ts:8:10:8:20 | type C = A; | tst.ts:8:15:8:15 | C | 0 | tst.ts:8:19:8:19 | A | @@ -7,38 +6,3 @@ | tst.ts:18:1:18:21 | type Un ... Union2; | tst.ts:18:6:18:11 | Union3 | 0 | tst.ts:18:15:18:20 | Union2 | | tst.ts:19:1:19:21 | type Un ... Union3; | tst.ts:19:6:19:11 | Union4 | 0 | tst.ts:19:15:19:20 | Union3 | | tst.ts:20:1:20:30 | type Un ... number; | tst.ts:20:6:20:11 | Union5 | 0 | tst.ts:20:15:20:29 | Union4 \| number | -rightHandSide -| tst.ts:1:1:1:16 | type A = number; | number | -| tst.ts:2:1:2:16 | type B = T[]; | T[] | -| tst.ts:8:10:8:20 | type C = A; | number | -| tst.ts:15:1:15:23 | type Un ... \| Two; | One \| Two | -| tst.ts:17:1:17:36 | type Un ... mber }; | Union & { x: number; } | -| tst.ts:18:1:18:21 | type Un ... Union2; | Union & { x: number; } | -| tst.ts:19:1:19:21 | type Un ... Union3; | Union & { x: number; } | -| tst.ts:20:1:20:30 | type Un ... number; | number \| Union2 | -getAliasedType -| B | T[] | -| B | number[] | -| Union | One \| Two | -| Union2 | Union & { x: number; } | -| Union5 | number \| Union2 | -getTypeArgument -| B | 0 | T | -| B | 0 | number | -unfold -| B | B | -| B | T[] | -| B | B | -| B | number[] | -| Union | One | -| Union | Two | -| Union | Union | -| Union2 | One | -| Union2 | Two | -| Union2 | Union2 | -| Union2 | { x: number; } | -| Union5 | One | -| Union5 | Two | -| Union5 | Union5 | -| Union5 | number | -| Union5 | { x: number; } | diff --git a/javascript/ql/test/library-tests/TypeScript/TypeAliases/TypeAliases.ql b/javascript/ql/test/library-tests/TypeScript/TypeAliases/TypeAliases.ql index e8133898ff23..2e1eae5f8dad 100644 --- a/javascript/ql/test/library-tests/TypeScript/TypeAliases/TypeAliases.ql +++ b/javascript/ql/test/library-tests/TypeScript/TypeAliases/TypeAliases.ql @@ -2,11 +2,3 @@ import javascript from TypeAliasDeclaration decl select decl, decl.getIdentifier(), decl.getNumTypeParameter(), decl.getDefinition() - -query Type rightHandSide(TypeAliasDeclaration decl) { result = decl.getDefinition().getType() } - -query Type getAliasedType(TypeAliasReference ref) { result = ref.getAliasedType() } - -query Type getTypeArgument(TypeAliasReference ref, int n) { result = ref.getTypeArgument(n) } - -query Type unfold(TypeAliasReference t) { result = t.unfold() } diff --git a/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tests.expected b/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tests.expected deleted file mode 100644 index 8bdb4cbe3324..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tests.expected +++ /dev/null @@ -1,28 +0,0 @@ -canonicalTypeVariableType -| T | GenericMethods.T in global scope | -| T | Repeated.T in global scope | -lexicalTypeVariableType -| D | D | -| E | E | -| S | S | -signatureTypeParameters -| (x: D): D | 0 | 1 | D | no bound | -| (x: () => E): E | 0 | 1 | E | no bound | -| (x: E[] \| (() => E)): E | 0 | 1 | E | no bound | -| (x: E[]): E | 0 | 1 | E | no bound | -| (x: S, y: T[]): S | 0 | 1 | S | any[] | -| (x: S, y: S): S | 0 | 1 | S | no bound | -| (x: S, y: T): [S, T] | 0 | 1 | S | no bound | -thisType -| Apple.this | Apple | -| Banana.this | Banana | -typeVariableCanonicalNames -| T | GenericMethods.T in global scope | -| T | Repeated.T in global scope | -typeVariableDecl -| T | GenericMethods.T in global scope | tst.ts:22:26:22:26 | T | -| T | Repeated.T in global scope | tst.ts:3:20:3:20 | T | -| T | Repeated.T in global scope | tst.ts:7:20:7:20 | T | -typeVariableHost -| T | GenericMethods.T in global scope | GenericMethods in global scope | -| T | Repeated.T in global scope | Repeated in global scope | diff --git a/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tests.ql b/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tests.ql deleted file mode 100644 index 3971f3d6437b..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tests.ql +++ /dev/null @@ -1,43 +0,0 @@ -import javascript - -query predicate canonicalTypeVariableType(CanonicalTypeVariableType type, CanonicalName name) { - type.getCanonicalName() = name -} - -query predicate lexicalTypeVariableType(LexicalTypeVariableType type, string name) { - type.getName() = name -} - -string getBound(CallSignatureType sig, int n) { - result = sig.getTypeParameterBound(n).toString() - or - not exists(sig.getTypeParameterBound(n)) and - result = "no bound" and - n = [0 .. sig.getNumTypeParameter() - 1] -} - -query predicate signatureTypeParameters( - CallSignatureType sig, int n, int numTypeParam, string paramName, string bound -) { - sig.getNumTypeParameter() = numTypeParam and - sig.getTypeParameterName(n) = paramName and - bound = getBound(sig, n) -} - -query predicate thisType(ThisType type, TypeReference enclosing) { - type.getEnclosingType() = enclosing -} - -query predicate typeVariableCanonicalNames(TypeVariableType type, CanonicalName name) { - type.getCanonicalName() = name -} - -query predicate typeVariableDecl(TypeVariableType tv, CanonicalName name, TypeParameter decl) { - tv.getCanonicalName() = name and - tv.getADeclaration() = decl -} - -query predicate typeVariableHost(TypeVariableType type, CanonicalName name, TypeName hostType) { - type.getCanonicalName() = name and - type.getHostType() = hostType -} diff --git a/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tsconfig.json deleted file mode 100644 index 0967ef424bce..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tsconfig.json +++ /dev/null @@ -1 +0,0 @@ -{} diff --git a/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tst.ts b/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tst.ts deleted file mode 100644 index ab3c2052c74f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/TypeVariableTypes/tst.ts +++ /dev/null @@ -1,34 +0,0 @@ -// There should only be one canonical type variable for `T` below. - -interface Repeated { - x: T; -} - -interface Repeated { - y: T; -} - - -function genericFunction(x: D): D { - return x; -} - -function overloaded(x: E[]): E; -function overloaded(x: () => E): E; -function overloaded(x: E[] | (() => E)): E { - return null; -} - -interface GenericMethods { - method(x: S, y: T[]): S; - method(x: S, y: T): [S, T]; - method(x: S, y: S): S; - method(x: any, y: any): any; -} - -interface Banana { - getThisBanana(): this; -} -interface Apple { - getThisApple(): this; -} diff --git a/javascript/ql/test/library-tests/TypeScript/Types/badTypes.ts b/javascript/ql/test/library-tests/TypeScript/Types/badTypes.ts deleted file mode 100644 index c8b819e1ee73..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/badTypes.ts +++ /dev/null @@ -1,6 +0,0 @@ -// Test case taken from babel: https://github.com/babel/babel/blob/main/packages/babel-parser/test/fixtures/typescript/regression/keyword-qualified-type-2/input.ts - -// These are valid TypeScript syntax (the parser doesn't produce any error), -// but they are always type-checking errors. -interface A extends this.B {} -type T = typeof var.bar; diff --git a/javascript/ql/test/library-tests/TypeScript/Types/boolean-type.ts b/javascript/ql/test/library-tests/TypeScript/Types/boolean-type.ts deleted file mode 100644 index f19b1d913c26..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/boolean-type.ts +++ /dev/null @@ -1,15 +0,0 @@ -import * as dummy from "./dummy"; - -var true1: true; -var true2: true | true; - -var false1: false; -var false2: false | false; - -var boolean1: boolean; -var boolean2: true | false; -var boolean3: false | true; - -var boolean4: boolean | boolean; -var boolean5: boolean | true; -var boolean6: false | boolean; diff --git a/javascript/ql/test/library-tests/TypeScript/Types/dummy.ts b/javascript/ql/test/library-tests/TypeScript/Types/dummy.ts deleted file mode 100644 index d36be434986c..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/dummy.ts +++ /dev/null @@ -1,4 +0,0 @@ -// Dummy file to be imported so the other files are seen as modules. -export let x = 5; - -export let reg = /ab+c/; \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/Types/middle-rest.ts b/javascript/ql/test/library-tests/TypeScript/Types/middle-rest.ts deleted file mode 100644 index 4ca8c74d334d..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/middle-rest.ts +++ /dev/null @@ -1,3 +0,0 @@ -let foo: [boolean, ...string[], number]; - -foo = [true, "hello", 123]; \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/Types/printAst.expected b/javascript/ql/test/library-tests/TypeScript/Types/printAst.expected deleted file mode 100644 index 3860acf0afb3..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/printAst.expected +++ /dev/null @@ -1,6042 +0,0 @@ -nodes -| badTypes.ts:5:1:5:29 | [InterfaceDeclaration,TypeDefinition] interfa ... is.B {} | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... is.B {} | -| badTypes.ts:5:1:5:29 | [InterfaceDeclaration,TypeDefinition] interfa ... is.B {} | semmle.order | 1 | -| badTypes.ts:5:11:5:11 | [Identifier] A | semmle.label | [Identifier] A | -| badTypes.ts:6:1:6:24 | [TypeAliasDeclaration,TypeDefinition] type T ... ar.bar; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type T ... ar.bar; | -| badTypes.ts:6:1:6:24 | [TypeAliasDeclaration,TypeDefinition] type T ... ar.bar; | semmle.order | 2 | -| badTypes.ts:6:6:6:6 | [Identifier] T | semmle.label | [Identifier] T | -| badTypes.ts:6:10:6:23 | [TypeofTypeExpr] typeof var.bar | semmle.label | [TypeofTypeExpr] typeof var.bar | -| badTypes.ts:6:17:6:19 | [LocalVarTypeAccess] var | semmle.label | [LocalVarTypeAccess] var | -| badTypes.ts:6:17:6:23 | [VarTypeAccess] var.bar | semmle.label | [VarTypeAccess] var.bar | -| badTypes.ts:6:21:6:23 | [Identifier] bar | semmle.label | [Identifier] bar | -| boolean-type.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | semmle.label | [ImportDeclaration] import ... dummy"; | -| boolean-type.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | semmle.order | 3 | -| boolean-type.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.label | [ImportSpecifier] * as dummy | -| boolean-type.ts:1:13:1:17 | [VarDecl] dummy | semmle.label | [VarDecl] dummy | -| boolean-type.ts:1:24:1:32 | [Literal] "./dummy" | semmle.label | [Literal] "./dummy" | -| boolean-type.ts:3:1:3:16 | [DeclStmt] var true1 = ... | semmle.label | [DeclStmt] var true1 = ... | -| boolean-type.ts:3:1:3:16 | [DeclStmt] var true1 = ... | semmle.order | 4 | -| boolean-type.ts:3:5:3:9 | [VarDecl] true1 | semmle.label | [VarDecl] true1 | -| boolean-type.ts:3:5:3:15 | [VariableDeclarator] true1: true | semmle.label | [VariableDeclarator] true1: true | -| boolean-type.ts:3:12:3:15 | [LiteralTypeExpr] true | semmle.label | [LiteralTypeExpr] true | -| boolean-type.ts:4:1:4:23 | [DeclStmt] var true2 = ... | semmle.label | [DeclStmt] var true2 = ... | -| boolean-type.ts:4:1:4:23 | [DeclStmt] var true2 = ... | semmle.order | 5 | -| boolean-type.ts:4:5:4:9 | [VarDecl] true2 | semmle.label | [VarDecl] true2 | -| boolean-type.ts:4:5:4:22 | [VariableDeclarator] true2: true \| true | semmle.label | [VariableDeclarator] true2: true \| true | -| boolean-type.ts:4:12:4:15 | [LiteralTypeExpr] true | semmle.label | [LiteralTypeExpr] true | -| boolean-type.ts:4:12:4:22 | [UnionTypeExpr] true \| true | semmle.label | [UnionTypeExpr] true \| true | -| boolean-type.ts:4:19:4:22 | [LiteralTypeExpr] true | semmle.label | [LiteralTypeExpr] true | -| boolean-type.ts:6:1:6:18 | [DeclStmt] var false1 = ... | semmle.label | [DeclStmt] var false1 = ... | -| boolean-type.ts:6:1:6:18 | [DeclStmt] var false1 = ... | semmle.order | 6 | -| boolean-type.ts:6:5:6:10 | [VarDecl] false1 | semmle.label | [VarDecl] false1 | -| boolean-type.ts:6:5:6:17 | [VariableDeclarator] false1: false | semmle.label | [VariableDeclarator] false1: false | -| boolean-type.ts:6:13:6:17 | [LiteralTypeExpr] false | semmle.label | [LiteralTypeExpr] false | -| boolean-type.ts:7:1:7:26 | [DeclStmt] var false2 = ... | semmle.label | [DeclStmt] var false2 = ... | -| boolean-type.ts:7:1:7:26 | [DeclStmt] var false2 = ... | semmle.order | 7 | -| boolean-type.ts:7:5:7:10 | [VarDecl] false2 | semmle.label | [VarDecl] false2 | -| boolean-type.ts:7:5:7:25 | [VariableDeclarator] false2: ... \| false | semmle.label | [VariableDeclarator] false2: ... \| false | -| boolean-type.ts:7:13:7:17 | [LiteralTypeExpr] false | semmle.label | [LiteralTypeExpr] false | -| boolean-type.ts:7:13:7:25 | [UnionTypeExpr] false \| false | semmle.label | [UnionTypeExpr] false \| false | -| boolean-type.ts:7:21:7:25 | [LiteralTypeExpr] false | semmle.label | [LiteralTypeExpr] false | -| boolean-type.ts:9:1:9:22 | [DeclStmt] var boolean1 = ... | semmle.label | [DeclStmt] var boolean1 = ... | -| boolean-type.ts:9:1:9:22 | [DeclStmt] var boolean1 = ... | semmle.order | 8 | -| boolean-type.ts:9:5:9:12 | [VarDecl] boolean1 | semmle.label | [VarDecl] boolean1 | -| boolean-type.ts:9:5:9:21 | [VariableDeclarator] boolean1: boolean | semmle.label | [VariableDeclarator] boolean1: boolean | -| boolean-type.ts:9:15:9:21 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| boolean-type.ts:10:1:10:27 | [DeclStmt] var boolean2 = ... | semmle.label | [DeclStmt] var boolean2 = ... | -| boolean-type.ts:10:1:10:27 | [DeclStmt] var boolean2 = ... | semmle.order | 9 | -| boolean-type.ts:10:5:10:12 | [VarDecl] boolean2 | semmle.label | [VarDecl] boolean2 | -| boolean-type.ts:10:5:10:26 | [VariableDeclarator] boolean ... \| false | semmle.label | [VariableDeclarator] boolean ... \| false | -| boolean-type.ts:10:15:10:18 | [LiteralTypeExpr] true | semmle.label | [LiteralTypeExpr] true | -| boolean-type.ts:10:15:10:26 | [UnionTypeExpr] true \| false | semmle.label | [UnionTypeExpr] true \| false | -| boolean-type.ts:10:22:10:26 | [LiteralTypeExpr] false | semmle.label | [LiteralTypeExpr] false | -| boolean-type.ts:11:1:11:27 | [DeclStmt] var boolean3 = ... | semmle.label | [DeclStmt] var boolean3 = ... | -| boolean-type.ts:11:1:11:27 | [DeclStmt] var boolean3 = ... | semmle.order | 10 | -| boolean-type.ts:11:5:11:12 | [VarDecl] boolean3 | semmle.label | [VarDecl] boolean3 | -| boolean-type.ts:11:5:11:26 | [VariableDeclarator] boolean ... \| true | semmle.label | [VariableDeclarator] boolean ... \| true | -| boolean-type.ts:11:15:11:19 | [LiteralTypeExpr] false | semmle.label | [LiteralTypeExpr] false | -| boolean-type.ts:11:15:11:26 | [UnionTypeExpr] false \| true | semmle.label | [UnionTypeExpr] false \| true | -| boolean-type.ts:11:23:11:26 | [LiteralTypeExpr] true | semmle.label | [LiteralTypeExpr] true | -| boolean-type.ts:13:1:13:32 | [DeclStmt] var boolean4 = ... | semmle.label | [DeclStmt] var boolean4 = ... | -| boolean-type.ts:13:1:13:32 | [DeclStmt] var boolean4 = ... | semmle.order | 11 | -| boolean-type.ts:13:5:13:12 | [VarDecl] boolean4 | semmle.label | [VarDecl] boolean4 | -| boolean-type.ts:13:5:13:31 | [VariableDeclarator] boolean ... boolean | semmle.label | [VariableDeclarator] boolean ... boolean | -| boolean-type.ts:13:15:13:21 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| boolean-type.ts:13:15:13:31 | [UnionTypeExpr] boolean \| boolean | semmle.label | [UnionTypeExpr] boolean \| boolean | -| boolean-type.ts:13:25:13:31 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| boolean-type.ts:14:1:14:29 | [DeclStmt] var boolean5 = ... | semmle.label | [DeclStmt] var boolean5 = ... | -| boolean-type.ts:14:1:14:29 | [DeclStmt] var boolean5 = ... | semmle.order | 12 | -| boolean-type.ts:14:5:14:12 | [VarDecl] boolean5 | semmle.label | [VarDecl] boolean5 | -| boolean-type.ts:14:5:14:28 | [VariableDeclarator] boolean ... \| true | semmle.label | [VariableDeclarator] boolean ... \| true | -| boolean-type.ts:14:15:14:21 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| boolean-type.ts:14:15:14:28 | [UnionTypeExpr] boolean \| true | semmle.label | [UnionTypeExpr] boolean \| true | -| boolean-type.ts:14:25:14:28 | [LiteralTypeExpr] true | semmle.label | [LiteralTypeExpr] true | -| boolean-type.ts:15:1:15:30 | [DeclStmt] var boolean6 = ... | semmle.label | [DeclStmt] var boolean6 = ... | -| boolean-type.ts:15:1:15:30 | [DeclStmt] var boolean6 = ... | semmle.order | 13 | -| boolean-type.ts:15:5:15:12 | [VarDecl] boolean6 | semmle.label | [VarDecl] boolean6 | -| boolean-type.ts:15:5:15:29 | [VariableDeclarator] boolean ... boolean | semmle.label | [VariableDeclarator] boolean ... boolean | -| boolean-type.ts:15:15:15:19 | [LiteralTypeExpr] false | semmle.label | [LiteralTypeExpr] false | -| boolean-type.ts:15:15:15:29 | [UnionTypeExpr] false \| boolean | semmle.label | [UnionTypeExpr] false \| boolean | -| boolean-type.ts:15:23:15:29 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| dummy.ts:2:1:2:17 | [ExportDeclaration] export let x = 5; | semmle.label | [ExportDeclaration] export let x = 5; | -| dummy.ts:2:1:2:17 | [ExportDeclaration] export let x = 5; | semmle.order | 14 | -| dummy.ts:2:8:2:17 | [DeclStmt] let x = ... | semmle.label | [DeclStmt] let x = ... | -| dummy.ts:2:12:2:12 | [VarDecl] x | semmle.label | [VarDecl] x | -| dummy.ts:2:12:2:16 | [VariableDeclarator] x = 5 | semmle.label | [VariableDeclarator] x = 5 | -| dummy.ts:2:16:2:16 | [Literal] 5 | semmle.label | [Literal] 5 | -| dummy.ts:4:1:4:24 | [ExportDeclaration] export ... /ab+c/; | semmle.label | [ExportDeclaration] export ... /ab+c/; | -| dummy.ts:4:1:4:24 | [ExportDeclaration] export ... /ab+c/; | semmle.order | 15 | -| dummy.ts:4:8:4:24 | [DeclStmt] let reg = ... | semmle.label | [DeclStmt] let reg = ... | -| dummy.ts:4:12:4:14 | [VarDecl] reg | semmle.label | [VarDecl] reg | -| dummy.ts:4:12:4:23 | [VariableDeclarator] reg = /ab+c/ | semmle.label | [VariableDeclarator] reg = /ab+c/ | -| dummy.ts:4:18:4:23 | [RegExpLiteral] /ab+c/ | semmle.label | [RegExpLiteral] /ab+c/ | -| dummy.ts:4:19:4:19 | [RegExpNormalConstant] a | semmle.label | [RegExpNormalConstant] a | -| dummy.ts:4:19:4:22 | [RegExpSequence] ab+c | semmle.label | [RegExpSequence] ab+c | -| dummy.ts:4:20:4:20 | [RegExpNormalConstant] b | semmle.label | [RegExpNormalConstant] b | -| dummy.ts:4:20:4:21 | [RegExpPlus] b+ | semmle.label | [RegExpPlus] b+ | -| dummy.ts:4:22:4:22 | [RegExpNormalConstant] c | semmle.label | [RegExpNormalConstant] c | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Arguments) | semmle.label | (Arguments) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (Parameters) | semmle.label | (Parameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| file://:0:0:0:0 | (TypeParameters) | semmle.label | (TypeParameters) | -| middle-rest.ts:1:1:1:40 | [DeclStmt] let foo = ... | semmle.label | [DeclStmt] let foo = ... | -| middle-rest.ts:1:1:1:40 | [DeclStmt] let foo = ... | semmle.order | 16 | -| middle-rest.ts:1:5:1:7 | [VarDecl] foo | semmle.label | [VarDecl] foo | -| middle-rest.ts:1:5:1:39 | [VariableDeclarator] foo: [b ... number] | semmle.label | [VariableDeclarator] foo: [b ... number] | -| middle-rest.ts:1:10:1:39 | [TupleTypeExpr] [boolea ... number] | semmle.label | [TupleTypeExpr] [boolea ... number] | -| middle-rest.ts:1:11:1:17 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| middle-rest.ts:1:20:1:30 | [RestTypeExpr] ...string[] | semmle.label | [RestTypeExpr] ...string[] | -| middle-rest.ts:1:23:1:28 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| middle-rest.ts:1:23:1:30 | [ArrayTypeExpr] string[] | semmle.label | [ArrayTypeExpr] string[] | -| middle-rest.ts:1:33:1:38 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| middle-rest.ts:3:1:3:3 | [VarRef] foo | semmle.label | [VarRef] foo | -| middle-rest.ts:3:1:3:26 | [AssignExpr] foo = [ ... ", 123] | semmle.label | [AssignExpr] foo = [ ... ", 123] | -| middle-rest.ts:3:1:3:27 | [ExprStmt] foo = [ ... , 123]; | semmle.label | [ExprStmt] foo = [ ... , 123]; | -| middle-rest.ts:3:1:3:27 | [ExprStmt] foo = [ ... , 123]; | semmle.order | 17 | -| middle-rest.ts:3:7:3:26 | [ArrayExpr] [true, "hello", 123] | semmle.label | [ArrayExpr] [true, "hello", 123] | -| middle-rest.ts:3:8:3:11 | [Literal] true | semmle.label | [Literal] true | -| middle-rest.ts:3:14:3:20 | [Literal] "hello" | semmle.label | [Literal] "hello" | -| middle-rest.ts:3:23:3:25 | [Literal] 123 | semmle.label | [Literal] 123 | -| tsconfig.json:1:1:9:1 | [JsonObject] {compilerOptions: ...} | semmle.label | [JsonObject] {compilerOptions: ...} | -| tsconfig.json:1:1:9:1 | [JsonObject] {compilerOptions: ...} | semmle.order | 18 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | semmle.label | [JsonObject] {module: ...} | -| tsconfig.json:3:15:3:22 | [JsonString] "esnext" | semmle.label | [JsonString] "esnext" | -| tsconfig.json:4:15:4:22 | [JsonString] "esnext" | semmle.label | [JsonString] "esnext" | -| tsconfig.json:5:12:5:28 | [JsonArray] ["dom", ...] | semmle.label | [JsonArray] ["dom", ...] | -| tsconfig.json:5:13:5:17 | [JsonString] "dom" | semmle.label | [JsonString] "dom" | -| tsconfig.json:5:20:5:27 | [JsonString] "esnext" | semmle.label | [JsonString] "esnext" | -| tsconfig.json:6:26:6:29 | [JsonBoolean] true | semmle.label | [JsonBoolean] true | -| tsconfig.json:7:23:7:34 | [JsonArray] [".ios", ...] | semmle.label | [JsonArray] [".ios", ...] | -| tsconfig.json:7:24:7:29 | [JsonString] ".ios" | semmle.label | [JsonString] ".ios" | -| tsconfig.json:7:32:7:33 | [JsonString] "" | semmle.label | [JsonString] "" | -| tst.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | semmle.label | [ImportDeclaration] import ... dummy"; | -| tst.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | semmle.order | 19 | -| tst.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.label | [ImportSpecifier] * as dummy | -| tst.ts:1:13:1:17 | [VarDecl] dummy | semmle.label | [VarDecl] dummy | -| tst.ts:1:24:1:32 | [Literal] "./dummy" | semmle.label | [Literal] "./dummy" | -| tst.ts:3:1:3:19 | [DeclStmt] var numVar = ... | semmle.label | [DeclStmt] var numVar = ... | -| tst.ts:3:1:3:19 | [DeclStmt] var numVar = ... | semmle.order | 20 | -| tst.ts:3:5:3:10 | [VarDecl] numVar | semmle.label | [VarDecl] numVar | -| tst.ts:3:5:3:18 | [VariableDeclarator] numVar: number | semmle.label | [VariableDeclarator] numVar: number | -| tst.ts:3:13:3:18 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:5:1:5:18 | [DeclStmt] var num1 = ... | semmle.label | [DeclStmt] var num1 = ... | -| tst.ts:5:1:5:18 | [DeclStmt] var num1 = ... | semmle.order | 21 | -| tst.ts:5:5:5:8 | [VarDecl] num1 | semmle.label | [VarDecl] num1 | -| tst.ts:5:5:5:17 | [VariableDeclarator] num1 = numVar | semmle.label | [VariableDeclarator] num1 = numVar | -| tst.ts:5:12:5:17 | [VarRef] numVar | semmle.label | [VarRef] numVar | -| tst.ts:6:1:6:13 | [DeclStmt] var num2 = ... | semmle.label | [DeclStmt] var num2 = ... | -| tst.ts:6:1:6:13 | [DeclStmt] var num2 = ... | semmle.order | 22 | -| tst.ts:6:5:6:8 | [VarDecl] num2 | semmle.label | [VarDecl] num2 | -| tst.ts:6:5:6:12 | [VariableDeclarator] num2 = 5 | semmle.label | [VariableDeclarator] num2 = 5 | -| tst.ts:6:12:6:12 | [Literal] 5 | semmle.label | [Literal] 5 | -| tst.ts:7:1:7:23 | [DeclStmt] var num3 = ... | semmle.label | [DeclStmt] var num3 = ... | -| tst.ts:7:1:7:23 | [DeclStmt] var num3 = ... | semmle.order | 23 | -| tst.ts:7:5:7:8 | [VarDecl] num3 | semmle.label | [VarDecl] num3 | -| tst.ts:7:5:7:22 | [VariableDeclarator] num3 = num1 + num2 | semmle.label | [VariableDeclarator] num3 = num1 + num2 | -| tst.ts:7:12:7:15 | [VarRef] num1 | semmle.label | [VarRef] num1 | -| tst.ts:7:12:7:22 | [BinaryExpr] num1 + num2 | semmle.label | [BinaryExpr] num1 + num2 | -| tst.ts:7:19:7:22 | [VarRef] num2 | semmle.label | [VarRef] num2 | -| tst.ts:9:1:9:19 | [DeclStmt] var strVar = ... | semmle.label | [DeclStmt] var strVar = ... | -| tst.ts:9:1:9:19 | [DeclStmt] var strVar = ... | semmle.order | 24 | -| tst.ts:9:5:9:10 | [VarDecl] strVar | semmle.label | [VarDecl] strVar | -| tst.ts:9:5:9:18 | [VariableDeclarator] strVar: string | semmle.label | [VariableDeclarator] strVar: string | -| tst.ts:9:13:9:18 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:10:1:10:20 | [DeclStmt] var hello = ... | semmle.label | [DeclStmt] var hello = ... | -| tst.ts:10:1:10:20 | [DeclStmt] var hello = ... | semmle.order | 25 | -| tst.ts:10:5:10:9 | [VarDecl] hello | semmle.label | [VarDecl] hello | -| tst.ts:10:5:10:19 | [VariableDeclarator] hello = "hello" | semmle.label | [VariableDeclarator] hello = "hello" | -| tst.ts:10:13:10:19 | [Literal] "hello" | semmle.label | [Literal] "hello" | -| tst.ts:11:1:11:20 | [DeclStmt] var world = ... | semmle.label | [DeclStmt] var world = ... | -| tst.ts:11:1:11:20 | [DeclStmt] var world = ... | semmle.order | 26 | -| tst.ts:11:5:11:9 | [VarDecl] world | semmle.label | [VarDecl] world | -| tst.ts:11:5:11:19 | [VariableDeclarator] world = "world" | semmle.label | [VariableDeclarator] world = "world" | -| tst.ts:11:13:11:19 | [Literal] "world" | semmle.label | [Literal] "world" | -| tst.ts:12:1:12:30 | [DeclStmt] var msg = ... | semmle.label | [DeclStmt] var msg = ... | -| tst.ts:12:1:12:30 | [DeclStmt] var msg = ... | semmle.order | 27 | -| tst.ts:12:5:12:7 | [VarDecl] msg | semmle.label | [VarDecl] msg | -| tst.ts:12:5:12:29 | [VariableDeclarator] msg = h ... + world | semmle.label | [VariableDeclarator] msg = h ... + world | -| tst.ts:12:11:12:15 | [VarRef] hello | semmle.label | [VarRef] hello | -| tst.ts:12:11:12:21 | [BinaryExpr] hello + " " | semmle.label | [BinaryExpr] hello + " " | -| tst.ts:12:11:12:29 | [BinaryExpr] hello + " " + world | semmle.label | [BinaryExpr] hello + " " + world | -| tst.ts:12:19:12:21 | [Literal] " " | semmle.label | [Literal] " " | -| tst.ts:12:25:12:29 | [VarRef] world | semmle.label | [VarRef] world | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | semmle.label | [FunctionDeclStmt] functio ... + y; } | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | semmle.order | 28 | -| tst.ts:14:10:14:15 | [VarDecl] concat | semmle.label | [VarDecl] concat | -| tst.ts:14:17:14:17 | [SimpleParameter] x | semmle.label | [SimpleParameter] x | -| tst.ts:14:20:14:25 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:14:28:14:28 | [SimpleParameter] y | semmle.label | [SimpleParameter] y | -| tst.ts:14:31:14:36 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:14:40:14:45 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:14:47:14:63 | [BlockStmt] { return x + y; } | semmle.label | [BlockStmt] { return x + y; } | -| tst.ts:14:49:14:61 | [ReturnStmt] return x + y; | semmle.label | [ReturnStmt] return x + y; | -| tst.ts:14:56:14:56 | [VarRef] x | semmle.label | [VarRef] x | -| tst.ts:14:56:14:60 | [BinaryExpr] x + y | semmle.label | [BinaryExpr] x + y | -| tst.ts:14:60:14:60 | [VarRef] y | semmle.label | [VarRef] y | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | semmle.label | [FunctionDeclStmt] functio ... + y; } | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | semmle.order | 29 | -| tst.ts:16:10:16:12 | [VarDecl] add | semmle.label | [VarDecl] add | -| tst.ts:16:14:16:14 | [SimpleParameter] x | semmle.label | [SimpleParameter] x | -| tst.ts:16:17:16:22 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:16:25:16:25 | [SimpleParameter] y | semmle.label | [SimpleParameter] y | -| tst.ts:16:28:16:33 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:16:37:16:42 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:16:44:16:60 | [BlockStmt] { return x + y; } | semmle.label | [BlockStmt] { return x + y; } | -| tst.ts:16:46:16:58 | [ReturnStmt] return x + y; | semmle.label | [ReturnStmt] return x + y; | -| tst.ts:16:53:16:53 | [VarRef] x | semmle.label | [VarRef] x | -| tst.ts:16:53:16:57 | [BinaryExpr] x + y | semmle.label | [BinaryExpr] x + y | -| tst.ts:16:57:16:57 | [VarRef] y | semmle.label | [VarRef] y | -| tst.ts:18:1:18:40 | [FunctionDeclStmt] functio ... + y; } | semmle.label | [FunctionDeclStmt] functio ... + y; } | -| tst.ts:18:1:18:40 | [FunctionDeclStmt] functio ... + y; } | semmle.order | 30 | -| tst.ts:18:10:18:16 | [VarDecl] untyped | semmle.label | [VarDecl] untyped | -| tst.ts:18:18:18:18 | [SimpleParameter] x | semmle.label | [SimpleParameter] x | -| tst.ts:18:21:18:21 | [SimpleParameter] y | semmle.label | [SimpleParameter] y | -| tst.ts:18:24:18:40 | [BlockStmt] { return x + y; } | semmle.label | [BlockStmt] { return x + y; } | -| tst.ts:18:26:18:38 | [ReturnStmt] return x + y; | semmle.label | [ReturnStmt] return x + y; | -| tst.ts:18:33:18:33 | [VarRef] x | semmle.label | [VarRef] x | -| tst.ts:18:33:18:37 | [BinaryExpr] x + y | semmle.label | [BinaryExpr] x + y | -| tst.ts:18:37:18:37 | [VarRef] y | semmle.label | [VarRef] y | -| tst.ts:20:1:20:53 | [FunctionDeclStmt] functio ... + y; } | semmle.label | [FunctionDeclStmt] functio ... + y; } | -| tst.ts:20:1:20:53 | [FunctionDeclStmt] functio ... + y; } | semmle.order | 31 | -| tst.ts:20:10:20:21 | [VarDecl] partialTyped | semmle.label | [VarDecl] partialTyped | -| tst.ts:20:23:20:23 | [SimpleParameter] x | semmle.label | [SimpleParameter] x | -| tst.ts:20:26:20:26 | [SimpleParameter] y | semmle.label | [SimpleParameter] y | -| tst.ts:20:29:20:34 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:20:37:20:53 | [BlockStmt] { return x + y; } | semmle.label | [BlockStmt] { return x + y; } | -| tst.ts:20:39:20:51 | [ReturnStmt] return x + y; | semmle.label | [ReturnStmt] return x + y; | -| tst.ts:20:46:20:46 | [VarRef] x | semmle.label | [VarRef] x | -| tst.ts:20:46:20:50 | [BinaryExpr] x + y | semmle.label | [BinaryExpr] x + y | -| tst.ts:20:50:20:50 | [VarRef] y | semmle.label | [VarRef] y | -| tst.ts:22:1:22:34 | [ForOfStmt] for (le ... 2]) {} | semmle.label | [ForOfStmt] for (le ... 2]) {} | -| tst.ts:22:1:22:34 | [ForOfStmt] for (le ... 2]) {} | semmle.order | 32 | -| tst.ts:22:6:22:20 | [DeclStmt] let numFromLoop = ... | semmle.label | [DeclStmt] let numFromLoop = ... | -| tst.ts:22:10:22:20 | [VarDecl] numFromLoop | semmle.label | [VarDecl] numFromLoop | -| tst.ts:22:10:22:20 | [VariableDeclarator] numFromLoop | semmle.label | [VariableDeclarator] numFromLoop | -| tst.ts:22:25:22:30 | [ArrayExpr] [1, 2] | semmle.label | [ArrayExpr] [1, 2] | -| tst.ts:22:26:22:26 | [Literal] 1 | semmle.label | [Literal] 1 | -| tst.ts:22:29:22:29 | [Literal] 2 | semmle.label | [Literal] 2 | -| tst.ts:22:33:22:34 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:24:1:24:20 | [DeclStmt] let array = ... | semmle.label | [DeclStmt] let array = ... | -| tst.ts:24:1:24:20 | [DeclStmt] let array = ... | semmle.order | 33 | -| tst.ts:24:5:24:9 | [VarDecl] array | semmle.label | [VarDecl] array | -| tst.ts:24:5:24:19 | [VariableDeclarator] array: number[] | semmle.label | [VariableDeclarator] array: number[] | -| tst.ts:24:12:24:17 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:24:12:24:19 | [ArrayTypeExpr] number[] | semmle.label | [ArrayTypeExpr] number[] | -| tst.ts:26:1:26:25 | [DeclStmt] let voidType = ... | semmle.label | [DeclStmt] let voidType = ... | -| tst.ts:26:1:26:25 | [DeclStmt] let voidType = ... | semmle.order | 34 | -| tst.ts:26:5:26:12 | [VarDecl] voidType | semmle.label | [VarDecl] voidType | -| tst.ts:26:5:26:24 | [VariableDeclarator] voidType: () => void | semmle.label | [VariableDeclarator] voidType: () => void | -| tst.ts:26:15:26:24 | [FunctionExpr] () => void | semmle.label | [FunctionExpr] () => void | -| tst.ts:26:15:26:24 | [FunctionTypeExpr] () => void | semmle.label | [FunctionTypeExpr] () => void | -| tst.ts:26:21:26:24 | [KeywordTypeExpr] void | semmle.label | [KeywordTypeExpr] void | -| tst.ts:27:1:27:29 | [DeclStmt] let undefinedType = ... | semmle.label | [DeclStmt] let undefinedType = ... | -| tst.ts:27:1:27:29 | [DeclStmt] let undefinedType = ... | semmle.order | 35 | -| tst.ts:27:5:27:17 | [VarDecl] undefinedType | semmle.label | [VarDecl] undefinedType | -| tst.ts:27:5:27:28 | [VariableDeclarator] undefin ... defined | semmle.label | [VariableDeclarator] undefin ... defined | -| tst.ts:27:20:27:28 | [KeywordTypeExpr] undefined | semmle.label | [KeywordTypeExpr] undefined | -| tst.ts:28:1:28:26 | [DeclStmt] let nullType = ... | semmle.label | [DeclStmt] let nullType = ... | -| tst.ts:28:1:28:26 | [DeclStmt] let nullType = ... | semmle.order | 36 | -| tst.ts:28:5:28:12 | [VarDecl] nullType | semmle.label | [VarDecl] nullType | -| tst.ts:28:5:28:25 | [VariableDeclarator] nullTyp ... = null | semmle.label | [VariableDeclarator] nullTyp ... = null | -| tst.ts:28:15:28:18 | [KeywordTypeExpr] null | semmle.label | [KeywordTypeExpr] null | -| tst.ts:28:22:28:25 | [Literal] null | semmle.label | [Literal] null | -| tst.ts:29:1:29:27 | [DeclStmt] let neverType = ... | semmle.label | [DeclStmt] let neverType = ... | -| tst.ts:29:1:29:27 | [DeclStmt] let neverType = ... | semmle.order | 37 | -| tst.ts:29:5:29:13 | [VarDecl] neverType | semmle.label | [VarDecl] neverType | -| tst.ts:29:5:29:26 | [VariableDeclarator] neverTy ... > never | semmle.label | [VariableDeclarator] neverTy ... > never | -| tst.ts:29:16:29:26 | [FunctionExpr] () => never | semmle.label | [FunctionExpr] () => never | -| tst.ts:29:16:29:26 | [FunctionTypeExpr] () => never | semmle.label | [FunctionTypeExpr] () => never | -| tst.ts:29:22:29:26 | [KeywordTypeExpr] never | semmle.label | [KeywordTypeExpr] never | -| tst.ts:30:1:30:23 | [DeclStmt] let symbolType = ... | semmle.label | [DeclStmt] let symbolType = ... | -| tst.ts:30:1:30:23 | [DeclStmt] let symbolType = ... | semmle.order | 38 | -| tst.ts:30:5:30:14 | [VarDecl] symbolType | semmle.label | [VarDecl] symbolType | -| tst.ts:30:5:30:22 | [VariableDeclarator] symbolType: symbol | semmle.label | [VariableDeclarator] symbolType: symbol | -| tst.ts:30:17:30:22 | [KeywordTypeExpr] symbol | semmle.label | [KeywordTypeExpr] symbol | -| tst.ts:31:1:31:45 | [DeclStmt] const uniqueSymbolType = ... | semmle.label | [DeclStmt] const uniqueSymbolType = ... | -| tst.ts:31:1:31:45 | [DeclStmt] const uniqueSymbolType = ... | semmle.order | 39 | -| tst.ts:31:7:31:22 | [VarDecl] uniqueSymbolType | semmle.label | [VarDecl] uniqueSymbolType | -| tst.ts:31:7:31:44 | [VariableDeclarator] uniqueS ... = null | semmle.label | [VariableDeclarator] uniqueS ... = null | -| tst.ts:31:25:31:37 | [KeywordTypeExpr] unique symbol | semmle.label | [KeywordTypeExpr] unique symbol | -| tst.ts:31:41:31:44 | [Literal] null | semmle.label | [Literal] null | -| tst.ts:32:1:32:23 | [DeclStmt] let objectType = ... | semmle.label | [DeclStmt] let objectType = ... | -| tst.ts:32:1:32:23 | [DeclStmt] let objectType = ... | semmle.order | 40 | -| tst.ts:32:5:32:14 | [VarDecl] objectType | semmle.label | [VarDecl] objectType | -| tst.ts:32:5:32:22 | [VariableDeclarator] objectType: object | semmle.label | [VariableDeclarator] objectType: object | -| tst.ts:32:17:32:22 | [KeywordTypeExpr] object | semmle.label | [KeywordTypeExpr] object | -| tst.ts:33:1:33:39 | [DeclStmt] let intersection = ... | semmle.label | [DeclStmt] let intersection = ... | -| tst.ts:33:1:33:39 | [DeclStmt] let intersection = ... | semmle.order | 41 | -| tst.ts:33:5:33:16 | [VarDecl] intersection | semmle.label | [VarDecl] intersection | -| tst.ts:33:5:33:38 | [VariableDeclarator] interse ... string} | semmle.label | [VariableDeclarator] interse ... string} | -| tst.ts:33:19:33:24 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:33:19:33:38 | [IntersectionTypeExpr] string & {x: string} | semmle.label | [IntersectionTypeExpr] string & {x: string} | -| tst.ts:33:28:33:38 | [InterfaceTypeExpr] {x: string} | semmle.label | [InterfaceTypeExpr] {x: string} | -| tst.ts:33:29:33:29 | [Label] x | semmle.label | [Label] x | -| tst.ts:33:29:33:37 | [FieldDeclaration] x: string | semmle.label | [FieldDeclaration] x: string | -| tst.ts:33:32:33:37 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:34:1:34:28 | [DeclStmt] let tuple = ... | semmle.label | [DeclStmt] let tuple = ... | -| tst.ts:34:1:34:28 | [DeclStmt] let tuple = ... | semmle.order | 42 | -| tst.ts:34:5:34:9 | [VarDecl] tuple | semmle.label | [VarDecl] tuple | -| tst.ts:34:5:34:27 | [VariableDeclarator] tuple: ... string] | semmle.label | [VariableDeclarator] tuple: ... string] | -| tst.ts:34:12:34:27 | [TupleTypeExpr] [number, string] | semmle.label | [TupleTypeExpr] [number, string] | -| tst.ts:34:13:34:18 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:34:21:34:26 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:36:1:36:56 | [DeclStmt] let tupleWithOptionalElement = ... | semmle.label | [DeclStmt] let tupleWithOptionalElement = ... | -| tst.ts:36:1:36:56 | [DeclStmt] let tupleWithOptionalElement = ... | semmle.order | 43 | -| tst.ts:36:5:36:28 | [VarDecl] tupleWithOptionalElement | semmle.label | [VarDecl] tupleWithOptionalElement | -| tst.ts:36:5:36:55 | [VariableDeclarator] tupleWi ... umber?] | semmle.label | [VariableDeclarator] tupleWi ... umber?] | -| tst.ts:36:31:36:55 | [TupleTypeExpr] [number ... umber?] | semmle.label | [TupleTypeExpr] [number ... umber?] | -| tst.ts:36:32:36:37 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:36:40:36:45 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:36:48:36:53 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:36:48:36:54 | [OptionalTypeExpr] number? | semmle.label | [OptionalTypeExpr] number? | -| tst.ts:37:1:37:19 | [DeclStmt] let emptyTuple = ... | semmle.label | [DeclStmt] let emptyTuple = ... | -| tst.ts:37:1:37:19 | [DeclStmt] let emptyTuple = ... | semmle.order | 44 | -| tst.ts:37:5:37:14 | [VarDecl] emptyTuple | semmle.label | [VarDecl] emptyTuple | -| tst.ts:37:5:37:18 | [VariableDeclarator] emptyTuple: [] | semmle.label | [VariableDeclarator] emptyTuple: [] | -| tst.ts:37:17:37:18 | [TupleTypeExpr] [] | semmle.label | [TupleTypeExpr] [] | -| tst.ts:38:1:38:48 | [DeclStmt] let tupleWithRestElement = ... | semmle.label | [DeclStmt] let tupleWithRestElement = ... | -| tst.ts:38:1:38:48 | [DeclStmt] let tupleWithRestElement = ... | semmle.order | 45 | -| tst.ts:38:5:38:24 | [VarDecl] tupleWithRestElement | semmle.label | [VarDecl] tupleWithRestElement | -| tst.ts:38:5:38:47 | [VariableDeclarator] tupleWi ... ring[]] | semmle.label | [VariableDeclarator] tupleWi ... ring[]] | -| tst.ts:38:27:38:47 | [TupleTypeExpr] [number ... ring[]] | semmle.label | [TupleTypeExpr] [number ... ring[]] | -| tst.ts:38:28:38:33 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:38:36:38:46 | [RestTypeExpr] ...string[] | semmle.label | [RestTypeExpr] ...string[] | -| tst.ts:38:39:38:44 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:38:39:38:46 | [ArrayTypeExpr] string[] | semmle.label | [ArrayTypeExpr] string[] | -| tst.ts:39:1:39:69 | [DeclStmt] let tupleWithOptionalAndRestElements = ... | semmle.label | [DeclStmt] let tupleWithOptionalAndRestElements = ... | -| tst.ts:39:1:39:69 | [DeclStmt] let tupleWithOptionalAndRestElements = ... | semmle.order | 46 | -| tst.ts:39:5:39:36 | [VarDecl] tupleWithOptionalAndRestElements | semmle.label | [VarDecl] tupleWithOptionalAndRestElements | -| tst.ts:39:5:39:68 | [VariableDeclarator] tupleWi ... mber[]] | semmle.label | [VariableDeclarator] tupleWi ... mber[]] | -| tst.ts:39:39:39:68 | [TupleTypeExpr] [number ... mber[]] | semmle.label | [TupleTypeExpr] [number ... mber[]] | -| tst.ts:39:40:39:45 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:39:48:39:53 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:39:48:39:54 | [OptionalTypeExpr] string? | semmle.label | [OptionalTypeExpr] string? | -| tst.ts:39:57:39:67 | [RestTypeExpr] ...number[] | semmle.label | [RestTypeExpr] ...number[] | -| tst.ts:39:60:39:65 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:39:60:39:67 | [ArrayTypeExpr] number[] | semmle.label | [ArrayTypeExpr] number[] | -| tst.ts:40:1:40:25 | [DeclStmt] let unknownType = ... | semmle.label | [DeclStmt] let unknownType = ... | -| tst.ts:40:1:40:25 | [DeclStmt] let unknownType = ... | semmle.order | 47 | -| tst.ts:40:5:40:15 | [VarDecl] unknownType | semmle.label | [VarDecl] unknownType | -| tst.ts:40:5:40:24 | [VariableDeclarator] unknownType: unknown | semmle.label | [VariableDeclarator] unknownType: unknown | -| tst.ts:40:18:40:24 | [KeywordTypeExpr] unknown | semmle.label | [KeywordTypeExpr] unknown | -| tst.ts:42:1:42:40 | [DeclStmt] let constArrayLiteral = ... | semmle.label | [DeclStmt] let constArrayLiteral = ... | -| tst.ts:42:1:42:40 | [DeclStmt] let constArrayLiteral = ... | semmle.order | 48 | -| tst.ts:42:5:42:21 | [VarDecl] constArrayLiteral | semmle.label | [VarDecl] constArrayLiteral | -| tst.ts:42:5:42:39 | [VariableDeclarator] constAr ... s const | semmle.label | [VariableDeclarator] constAr ... s const | -| tst.ts:42:25:42:30 | [ArrayExpr] [1, 2] | semmle.label | [ArrayExpr] [1, 2] | -| tst.ts:42:25:42:39 | [TypeAssertion] [1, 2] as const | semmle.label | [TypeAssertion] [1, 2] as const | -| tst.ts:42:26:42:26 | [Literal] 1 | semmle.label | [Literal] 1 | -| tst.ts:42:29:42:29 | [Literal] 2 | semmle.label | [Literal] 2 | -| tst.ts:42:35:42:39 | [KeywordTypeExpr] const | semmle.label | [KeywordTypeExpr] const | -| tst.ts:43:1:43:49 | [DeclStmt] let constObjectLiteral = ... | semmle.label | [DeclStmt] let constObjectLiteral = ... | -| tst.ts:43:1:43:49 | [DeclStmt] let constObjectLiteral = ... | semmle.order | 49 | -| tst.ts:43:5:43:22 | [VarDecl] constObjectLiteral | semmle.label | [VarDecl] constObjectLiteral | -| tst.ts:43:5:43:48 | [VariableDeclarator] constOb ... s const | semmle.label | [VariableDeclarator] constOb ... s const | -| tst.ts:43:26:43:39 | [ObjectExpr] {foo: ...} | semmle.label | [ObjectExpr] {foo: ...} | -| tst.ts:43:26:43:48 | [TypeAssertion] { foo: ... s const | semmle.label | [TypeAssertion] { foo: ... s const | -| tst.ts:43:28:43:30 | [Label] foo | semmle.label | [Label] foo | -| tst.ts:43:28:43:37 | [Property] foo: "foo" | semmle.label | [Property] foo: "foo" | -| tst.ts:43:33:43:37 | [Literal] "foo" | semmle.label | [Literal] "foo" | -| tst.ts:43:44:43:48 | [KeywordTypeExpr] const | semmle.label | [KeywordTypeExpr] const | -| tst.ts:46:1:51:1 | [TryStmt] try { } ... ; } } | semmle.label | [TryStmt] try { } ... ; } } | -| tst.ts:46:1:51:1 | [TryStmt] try { } ... ; } } | semmle.order | 50 | -| tst.ts:46:5:46:7 | [BlockStmt] { } | semmle.label | [BlockStmt] { } | -| tst.ts:47:1:51:1 | [CatchClause] catch ( ... ; } } | semmle.label | [CatchClause] catch ( ... ; } } | -| tst.ts:47:8:47:8 | [SimpleParameter] e | semmle.label | [SimpleParameter] e | -| tst.ts:47:20:51:1 | [BlockStmt] { if ... ; } } | semmle.label | [BlockStmt] { if ... ; } } | -| tst.ts:48:3:50:3 | [IfStmt] if (typ ... e; } | semmle.label | [IfStmt] if (typ ... e; } | -| tst.ts:48:7:48:14 | [UnaryExpr] typeof e | semmle.label | [UnaryExpr] typeof e | -| tst.ts:48:7:48:27 | [BinaryExpr] typeof ... string" | semmle.label | [BinaryExpr] typeof ... string" | -| tst.ts:48:14:48:14 | [VarRef] e | semmle.label | [VarRef] e | -| tst.ts:48:20:48:27 | [Literal] "string" | semmle.label | [Literal] "string" | -| tst.ts:48:30:50:3 | [BlockStmt] { ... e; } | semmle.label | [BlockStmt] { ... e; } | -| tst.ts:49:7:49:25 | [DeclStmt] let b = ... | semmle.label | [DeclStmt] let b = ... | -| tst.ts:49:11:49:11 | [VarDecl] b | semmle.label | [VarDecl] b | -| tst.ts:49:11:49:24 | [VariableDeclarator] b : string = e | semmle.label | [VariableDeclarator] b : string = e | -| tst.ts:49:15:49:20 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:49:24:49:24 | [VarRef] e | semmle.label | [VarRef] e | -| tst.ts:54:1:56:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | -| tst.ts:54:1:56:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | semmle.order | 51 | -| tst.ts:54:11:54:26 | [Identifier] NonAbstractDummy | semmle.label | [Identifier] NonAbstractDummy | -| tst.ts:55:3:55:9 | [Label] getArea | semmle.label | [Label] getArea | -| tst.ts:55:3:55:20 | [FunctionExpr] getArea(): number; | semmle.label | [FunctionExpr] getArea(): number; | -| tst.ts:55:3:55:20 | [MethodSignature] getArea(): number; | semmle.label | [MethodSignature] getArea(): number; | -| tst.ts:55:14:55:19 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:58:1:60:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | -| tst.ts:58:1:60:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | semmle.order | 52 | -| tst.ts:58:11:58:17 | [Identifier] HasArea | semmle.label | [Identifier] HasArea | -| tst.ts:59:3:59:9 | [Label] getArea | semmle.label | [Label] getArea | -| tst.ts:59:3:59:20 | [FunctionExpr] getArea(): number; | semmle.label | [FunctionExpr] getArea(): number; | -| tst.ts:59:3:59:20 | [MethodSignature] getArea(): number; | semmle.label | [MethodSignature] getArea(): number; | -| tst.ts:59:14:59:19 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:63:1:63:45 | [DeclStmt] let Ctor = ... | semmle.label | [DeclStmt] let Ctor = ... | -| tst.ts:63:1:63:45 | [DeclStmt] let Ctor = ... | semmle.order | 53 | -| tst.ts:63:5:63:8 | [VarDecl] Ctor | semmle.label | [VarDecl] Ctor | -| tst.ts:63:5:63:44 | [VariableDeclarator] Ctor: a ... = Shape | semmle.label | [VariableDeclarator] Ctor: a ... = Shape | -| tst.ts:63:11:63:36 | [FunctionExpr] abstrac ... HasArea | semmle.label | [FunctionExpr] abstrac ... HasArea | -| tst.ts:63:11:63:36 | [FunctionTypeExpr] abstrac ... HasArea | semmle.label | [FunctionTypeExpr] abstrac ... HasArea | -| tst.ts:63:30:63:36 | [LocalTypeAccess] HasArea | semmle.label | [LocalTypeAccess] HasArea | -| tst.ts:63:40:63:44 | [VarRef] Shape | semmle.label | [VarRef] Shape | -| tst.ts:65:1:65:54 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | -| tst.ts:65:1:65:54 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | semmle.order | 54 | -| tst.ts:65:6:65:12 | [Identifier] MyUnion | semmle.label | [Identifier] MyUnion | -| tst.ts:65:16:65:30 | [InterfaceTypeExpr] {myUnion: true} | semmle.label | [InterfaceTypeExpr] {myUnion: true} | -| tst.ts:65:16:65:53 | [UnionTypeExpr] {myUnio ... : true} | semmle.label | [UnionTypeExpr] {myUnio ... : true} | -| tst.ts:65:17:65:23 | [Label] myUnion | semmle.label | [Label] myUnion | -| tst.ts:65:17:65:29 | [FieldDeclaration] myUnion: true | semmle.label | [FieldDeclaration] myUnion: true | -| tst.ts:65:26:65:29 | [LiteralTypeExpr] true | semmle.label | [LiteralTypeExpr] true | -| tst.ts:65:34:65:53 | [InterfaceTypeExpr] {stillMyUnion: true} | semmle.label | [InterfaceTypeExpr] {stillMyUnion: true} | -| tst.ts:65:35:65:46 | [Label] stillMyUnion | semmle.label | [Label] stillMyUnion | -| tst.ts:65:35:65:52 | [FieldDeclaration] stillMyUnion: true | semmle.label | [FieldDeclaration] stillMyUnion: true | -| tst.ts:65:49:65:52 | [LiteralTypeExpr] true | semmle.label | [LiteralTypeExpr] true | -| tst.ts:66:1:66:38 | [DeclStmt] let union1 = ... | semmle.label | [DeclStmt] let union1 = ... | -| tst.ts:66:1:66:38 | [DeclStmt] let union1 = ... | semmle.order | 55 | -| tst.ts:66:5:66:10 | [VarDecl] union1 | semmle.label | [VarDecl] union1 | -| tst.ts:66:5:66:37 | [VariableDeclarator] union1: ... : true} | semmle.label | [VariableDeclarator] union1: ... : true} | -| tst.ts:66:13:66:19 | [LocalTypeAccess] MyUnion | semmle.label | [LocalTypeAccess] MyUnion | -| tst.ts:66:23:66:37 | [ObjectExpr] {myUnion: ...} | semmle.label | [ObjectExpr] {myUnion: ...} | -| tst.ts:66:24:66:30 | [Label] myUnion | semmle.label | [Label] myUnion | -| tst.ts:66:24:66:36 | [Property] myUnion: true | semmle.label | [Property] myUnion: true | -| tst.ts:66:33:66:36 | [Literal] true | semmle.label | [Literal] true | -| tst.ts:68:1:68:49 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | -| tst.ts:68:1:68:49 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | semmle.order | 56 | -| tst.ts:68:6:68:13 | [Identifier] MyUnion2 | semmle.label | [Identifier] MyUnion2 | -| tst.ts:68:17:68:23 | [LocalTypeAccess] MyUnion | semmle.label | [LocalTypeAccess] MyUnion | -| tst.ts:68:17:68:48 | [UnionTypeExpr] MyUnion ... : true} | semmle.label | [UnionTypeExpr] MyUnion ... : true} | -| tst.ts:68:27:68:48 | [InterfaceTypeExpr] {yetAno ... : true} | semmle.label | [InterfaceTypeExpr] {yetAno ... : true} | -| tst.ts:68:28:68:41 | [Label] yetAnotherType | semmle.label | [Label] yetAnotherType | -| tst.ts:68:28:68:47 | [FieldDeclaration] yetAnotherType: true | semmle.label | [FieldDeclaration] yetAnotherType: true | -| tst.ts:68:44:68:47 | [LiteralTypeExpr] true | semmle.label | [LiteralTypeExpr] true | -| tst.ts:69:1:69:46 | [DeclStmt] let union2 = ... | semmle.label | [DeclStmt] let union2 = ... | -| tst.ts:69:1:69:46 | [DeclStmt] let union2 = ... | semmle.order | 57 | -| tst.ts:69:5:69:10 | [VarDecl] union2 | semmle.label | [VarDecl] union2 | -| tst.ts:69:5:69:45 | [VariableDeclarator] union2: ... : true} | semmle.label | [VariableDeclarator] union2: ... : true} | -| tst.ts:69:13:69:20 | [LocalTypeAccess] MyUnion2 | semmle.label | [LocalTypeAccess] MyUnion2 | -| tst.ts:69:24:69:45 | [ObjectExpr] {yetAnotherType: ...} | semmle.label | [ObjectExpr] {yetAnotherType: ...} | -| tst.ts:69:25:69:38 | [Label] yetAnotherType | semmle.label | [Label] yetAnotherType | -| tst.ts:69:25:69:44 | [Property] yetAnotherType: true | semmle.label | [Property] yetAnotherType: true | -| tst.ts:69:41:69:44 | [Literal] true | semmle.label | [Literal] true | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | semmle.label | [NamespaceDeclaration] module ... } } | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | semmle.order | 58 | -| tst.ts:71:8:71:11 | [VarDecl] TS43 | semmle.label | [VarDecl] TS43 | -| tst.ts:73:3:76:3 | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | -| tst.ts:73:13:73:18 | [Identifier] ThingI | semmle.label | [Identifier] ThingI | -| tst.ts:74:5:74:22 | [FunctionExpr] get size(): number | semmle.label | [FunctionExpr] get size(): number | -| tst.ts:74:5:74:22 | [GetterMethodSignature] get size(): number | semmle.label | [GetterMethodSignature] get size(): number | -| tst.ts:74:9:74:12 | [Label] size | semmle.label | [Label] size | -| tst.ts:74:17:74:22 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:75:5:75:47 | [FunctionExpr] set siz ... olean); | semmle.label | [FunctionExpr] set siz ... olean); | -| tst.ts:75:5:75:47 | [SetterMethodSignature] set siz ... olean); | semmle.label | [SetterMethodSignature] set siz ... olean); | -| tst.ts:75:9:75:12 | [Label] size | semmle.label | [Label] size | -| tst.ts:75:14:75:18 | [SimpleParameter] value | semmle.label | [SimpleParameter] value | -| tst.ts:75:21:75:26 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:75:21:75:45 | [UnionTypeExpr] number ... boolean | semmle.label | [UnionTypeExpr] number ... boolean | -| tst.ts:75:30:75:35 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:75:39:75:45 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| tst.ts:78:3:88:3 | [ExportDeclaration] export ... } } | semmle.label | [ExportDeclaration] export ... } } | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | semmle.label | [ClassDefinition,TypeDefinition] class T ... } } | -| tst.ts:78:16:78:20 | [VarDecl] Thing | semmle.label | [VarDecl] Thing | -| tst.ts:78:33:78:38 | [LocalTypeAccess] ThingI | semmle.label | [LocalTypeAccess] ThingI | -| tst.ts:78:40:78:39 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:78:40:78:39 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | [ClassInitializedMember,ConstructorDefinition] constructor() {} | -| tst.ts:78:40:78:39 | [FunctionExpr] () {} | semmle.label | [FunctionExpr] () {} | -| tst.ts:78:40:78:39 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:79:5:79:9 | [Label] #size | semmle.label | [Label] #size | -| tst.ts:79:5:79:14 | [FieldDeclaration] #size = 0; | semmle.label | [FieldDeclaration] #size = 0; | -| tst.ts:79:13:79:13 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:81:5:83:5 | [ClassInitializedMember,GetterMethodDefinition] get siz ... ; } | semmle.label | [ClassInitializedMember,GetterMethodDefinition] get siz ... ; } | -| tst.ts:81:5:83:5 | [FunctionExpr] get siz ... ; } | semmle.label | [FunctionExpr] get siz ... ; } | -| tst.ts:81:9:81:12 | [Label] size | semmle.label | [Label] size | -| tst.ts:81:17:81:22 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:81:24:83:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:82:7:82:24 | [ReturnStmt] return this.#size; | semmle.label | [ReturnStmt] return this.#size; | -| tst.ts:82:14:82:17 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:82:14:82:23 | [DotExpr] this.#size | semmle.label | [DotExpr] this.#size | -| tst.ts:82:19:82:23 | [Label] #size | semmle.label | [Label] #size | -| tst.ts:85:5:87:5 | [ClassInitializedMember,SetterMethodDefinition] set siz ... ; } | semmle.label | [ClassInitializedMember,SetterMethodDefinition] set siz ... ; } | -| tst.ts:85:5:87:5 | [FunctionExpr] set siz ... ; } | semmle.label | [FunctionExpr] set siz ... ; } | -| tst.ts:85:9:85:12 | [Label] size | semmle.label | [Label] size | -| tst.ts:85:14:85:18 | [SimpleParameter] value | semmle.label | [SimpleParameter] value | -| tst.ts:85:21:85:26 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:85:21:85:45 | [UnionTypeExpr] string ... boolean | semmle.label | [UnionTypeExpr] string ... boolean | -| tst.ts:85:30:85:35 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:85:39:85:45 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| tst.ts:85:48:87:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:86:7:86:10 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:86:7:86:16 | [DotExpr] this.#size | semmle.label | [DotExpr] this.#size | -| tst.ts:86:7:86:32 | [AssignExpr] this.#s ... (value) | semmle.label | [AssignExpr] this.#s ... (value) | -| tst.ts:86:7:86:33 | [ExprStmt] this.#s ... value); | semmle.label | [ExprStmt] this.#s ... value); | -| tst.ts:86:12:86:16 | [Label] #size | semmle.label | [Label] #size | -| tst.ts:86:20:86:25 | [VarRef] Number | semmle.label | [VarRef] Number | -| tst.ts:86:20:86:32 | [CallExpr] Number(value) | semmle.label | [CallExpr] Number(value) | -| tst.ts:86:27:86:31 | [VarRef] value | semmle.label | [VarRef] value | -| tst.ts:91:3:95:3 | [ClassDefinition,TypeDefinition] class S ... } } | semmle.label | [ClassDefinition,TypeDefinition] class S ... } } | -| tst.ts:91:9:91:13 | [VarDecl] Super | semmle.label | [VarDecl] Super | -| tst.ts:91:15:91:14 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:91:15:91:14 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | [ClassInitializedMember,ConstructorDefinition] constructor() {} | -| tst.ts:91:15:91:14 | [FunctionExpr] () {} | semmle.label | [FunctionExpr] () {} | -| tst.ts:91:15:91:14 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:92:5:92:10 | [Label] random | semmle.label | [Label] random | -| tst.ts:92:5:94:5 | [ClassInitializedMember,MethodDefinition] random( ... ; } | semmle.label | [ClassInitializedMember,MethodDefinition] random( ... ; } | -| tst.ts:92:5:94:5 | [FunctionExpr] random( ... ; } | semmle.label | [FunctionExpr] random( ... ; } | -| tst.ts:92:15:92:20 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:92:22:94:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:93:7:93:15 | [ReturnStmt] return 4; | semmle.label | [ReturnStmt] return 4; | -| tst.ts:93:14:93:14 | [Literal] 4 | semmle.label | [Literal] 4 | -| tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | semmle.label | [ClassDefinition,TypeDefinition] class S ... } } | -| tst.ts:97:9:97:11 | [VarDecl] Sub | semmle.label | [VarDecl] Sub | -| tst.ts:97:21:97:25 | [VarRef] Super | semmle.label | [VarRef] Super | -| tst.ts:97:27:97:26 | [BlockStmt] { super(...args); } | semmle.label | [BlockStmt] { super(...args); } | -| tst.ts:97:27:97:26 | [CallExpr] super(...args) | semmle.label | [CallExpr] super(...args) | -| tst.ts:97:27:97:26 | [ClassInitializedMember,ConstructorDefinition] constru ... rgs); } | semmle.label | [ClassInitializedMember,ConstructorDefinition] constru ... rgs); } | -| tst.ts:97:27:97:26 | [ExprStmt] super(...args); | semmle.label | [ExprStmt] super(...args); | -| tst.ts:97:27:97:26 | [FunctionExpr] (...arg ... rgs); } | semmle.label | [FunctionExpr] (...arg ... rgs); } | -| tst.ts:97:27:97:26 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:97:27:97:26 | [SimpleParameter] args | semmle.label | [SimpleParameter] args | -| tst.ts:97:27:97:26 | [SpreadElement] ...args | semmle.label | [SpreadElement] ...args | -| tst.ts:97:27:97:26 | [SuperExpr] super | semmle.label | [SuperExpr] super | -| tst.ts:97:27:97:26 | [VarRef] args | semmle.label | [VarRef] args | -| tst.ts:98:5:100:5 | [ClassInitializedMember,MethodDefinition] overrid ... ; } | semmle.label | [ClassInitializedMember,MethodDefinition] overrid ... ; } | -| tst.ts:98:5:100:5 | [FunctionExpr] overrid ... ; } | semmle.label | [FunctionExpr] overrid ... ; } | -| tst.ts:98:14:98:19 | [Label] random | semmle.label | [Label] random | -| tst.ts:98:24:98:29 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:98:31:100:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:99:7:99:33 | [ReturnStmt] return ... ) * 10; | semmle.label | [ReturnStmt] return ... ) * 10; | -| tst.ts:99:14:99:18 | [SuperExpr] super | semmle.label | [SuperExpr] super | -| tst.ts:99:14:99:25 | [DotExpr] super.random | semmle.label | [DotExpr] super.random | -| tst.ts:99:14:99:27 | [MethodCallExpr] super.random() | semmle.label | [MethodCallExpr] super.random() | -| tst.ts:99:14:99:32 | [BinaryExpr] super.random() * 10 | semmle.label | [BinaryExpr] super.random() * 10 | -| tst.ts:99:20:99:25 | [Label] random | semmle.label | [Label] random | -| tst.ts:99:31:99:32 | [Literal] 10 | semmle.label | [Literal] 10 | -| tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | semmle.label | [FunctionDeclStmt] functio ... }`; } | -| tst.ts:104:12:104:14 | [VarDecl] bar | semmle.label | [VarDecl] bar | -| tst.ts:104:16:104:16 | [SimpleParameter] s | semmle.label | [SimpleParameter] s | -| tst.ts:104:19:104:24 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:104:28:104:44 | [TemplateLiteralTypeExpr] `hello ${string}` | semmle.label | [TemplateLiteralTypeExpr] `hello ${string}` | -| tst.ts:104:29:104:34 | [LiteralTypeExpr] hello | semmle.label | [LiteralTypeExpr] hello | -| tst.ts:104:37:104:42 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:104:46:107:3 | [BlockStmt] { / ... }`; } | semmle.label | [BlockStmt] { / ... }`; } | -| tst.ts:106:5:106:24 | [ReturnStmt] return `hello ${s}`; | semmle.label | [ReturnStmt] return `hello ${s}`; | -| tst.ts:106:12:106:23 | [TemplateLiteral] `hello ${s}` | semmle.label | [TemplateLiteral] `hello ${s}` | -| tst.ts:106:13:106:18 | [TemplateElement] hello | semmle.label | [TemplateElement] hello | -| tst.ts:106:21:106:21 | [VarRef] s | semmle.label | [VarRef] s | -| tst.ts:109:3:109:50 | [DeclStmt] let s1 = ... | semmle.label | [DeclStmt] let s1 = ... | -| tst.ts:109:15:109:16 | [VarDecl] s1 | semmle.label | [VarDecl] s1 | -| tst.ts:109:15:109:49 | [VariableDeclarator] s1: `${ ... umber}` | semmle.label | [VariableDeclarator] s1: `${ ... umber}` | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | semmle.label | [TemplateLiteralTypeExpr] `${numb ... umber}` | -| tst.ts:109:22:109:27 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:109:29:109:29 | [LiteralTypeExpr] - | semmle.label | [LiteralTypeExpr] - | -| tst.ts:109:32:109:37 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:109:39:109:39 | [LiteralTypeExpr] - | semmle.label | [LiteralTypeExpr] - | -| tst.ts:109:42:109:47 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:110:3:110:26 | [DeclStmt] let s2 = ... | semmle.label | [DeclStmt] let s2 = ... | -| tst.ts:110:15:110:16 | [VarDecl] s2 | semmle.label | [VarDecl] s2 | -| tst.ts:110:15:110:25 | [VariableDeclarator] s2: `1-2-3` | semmle.label | [VariableDeclarator] s2: `1-2-3` | -| tst.ts:110:19:110:25 | [LiteralTypeExpr] `1-2-3` | semmle.label | [LiteralTypeExpr] `1-2-3` | -| tst.ts:110:19:110:25 | [TemplateLiteralTypeExpr] `1-2-3` | semmle.label | [TemplateLiteralTypeExpr] `1-2-3` | -| tst.ts:111:3:111:34 | [DeclStmt] let s3 = ... | semmle.label | [DeclStmt] let s3 = ... | -| tst.ts:111:15:111:16 | [VarDecl] s3 | semmle.label | [VarDecl] s3 | -| tst.ts:111:15:111:33 | [VariableDeclarator] s3: `${number}-2-3` | semmle.label | [VariableDeclarator] s3: `${number}-2-3` | -| tst.ts:111:19:111:33 | [TemplateLiteralTypeExpr] `${number}-2-3` | semmle.label | [TemplateLiteralTypeExpr] `${number}-2-3` | -| tst.ts:111:22:111:27 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:111:29:111:32 | [LiteralTypeExpr] -2-3 | semmle.label | [LiteralTypeExpr] -2-3 | -| tst.ts:112:3:112:4 | [VarRef] s1 | semmle.label | [VarRef] s1 | -| tst.ts:112:3:112:9 | [AssignExpr] s1 = s2 | semmle.label | [AssignExpr] s1 = s2 | -| tst.ts:112:3:112:10 | [ExprStmt] s1 = s2; | semmle.label | [ExprStmt] s1 = s2; | -| tst.ts:112:8:112:9 | [VarRef] s2 | semmle.label | [VarRef] s2 | -| tst.ts:113:3:113:4 | [VarRef] s1 | semmle.label | [VarRef] s1 | -| tst.ts:113:3:113:9 | [AssignExpr] s1 = s3 | semmle.label | [AssignExpr] s1 = s3 | -| tst.ts:113:3:113:10 | [ExprStmt] s1 = s3; | semmle.label | [ExprStmt] s1 = s3; | -| tst.ts:113:8:113:9 | [VarRef] s3 | semmle.label | [VarRef] s3 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | semmle.label | [ClassDefinition,TypeDefinition] class F ... } } | -| tst.ts:116:9:116:11 | [VarDecl] Foo | semmle.label | [VarDecl] Foo | -| tst.ts:116:13:116:12 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:116:13:116:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | [ClassInitializedMember,ConstructorDefinition] constructor() {} | -| tst.ts:116:13:116:12 | [FunctionExpr] () {} | semmle.label | [FunctionExpr] () {} | -| tst.ts:116:13:116:12 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:117:5:117:15 | [Label] #someMethod | semmle.label | [Label] #someMethod | -| tst.ts:117:5:119:5 | [ClassInitializedMember,MethodDefinition] #someMe ... ; } | semmle.label | [ClassInitializedMember,MethodDefinition] #someMe ... ; } | -| tst.ts:117:5:119:5 | [FunctionExpr] #someMe ... ; } | semmle.label | [FunctionExpr] #someMe ... ; } | -| tst.ts:117:20:117:25 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:117:27:119:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:118:7:118:16 | [ReturnStmt] return 42; | semmle.label | [ReturnStmt] return 42; | -| tst.ts:118:14:118:15 | [Literal] 42 | semmle.label | [Literal] 42 | -| tst.ts:121:5:123:5 | [ClassInitializedMember,GetterMethodDefinition] get #so ... ; } | semmle.label | [ClassInitializedMember,GetterMethodDefinition] get #so ... ; } | -| tst.ts:121:5:123:5 | [FunctionExpr] get #so ... ; } | semmle.label | [FunctionExpr] get #so ... ; } | -| tst.ts:121:9:121:18 | [Label] #someValue | semmle.label | [Label] #someValue | -| tst.ts:121:23:121:28 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:121:30:123:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:122:7:122:17 | [ReturnStmt] return 100; | semmle.label | [ReturnStmt] return 100; | -| tst.ts:122:14:122:16 | [Literal] 100 | semmle.label | [Literal] 100 | -| tst.ts:125:5:125:16 | [Label] publicMethod | semmle.label | [Label] publicMethod | -| tst.ts:125:5:128:5 | [ClassInitializedMember,MethodDefinition] publicM ... ; } | semmle.label | [ClassInitializedMember,MethodDefinition] publicM ... ; } | -| tst.ts:125:5:128:5 | [FunctionExpr] publicM ... ; } | semmle.label | [FunctionExpr] publicM ... ; } | -| tst.ts:125:20:128:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:126:7:126:10 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:126:7:126:22 | [DotExpr] this.#someMethod | semmle.label | [DotExpr] this.#someMethod | -| tst.ts:126:7:126:24 | [MethodCallExpr] this.#someMethod() | semmle.label | [MethodCallExpr] this.#someMethod() | -| tst.ts:126:7:126:25 | [ExprStmt] this.#someMethod(); | semmle.label | [ExprStmt] this.#someMethod(); | -| tst.ts:126:12:126:22 | [Label] #someMethod | semmle.label | [Label] #someMethod | -| tst.ts:127:7:127:29 | [ReturnStmt] return ... eValue; | semmle.label | [ReturnStmt] return ... eValue; | -| tst.ts:127:14:127:17 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:127:14:127:28 | [DotExpr] this.#someValue | semmle.label | [DotExpr] this.#someValue | -| tst.ts:127:19:127:28 | [Label] #someValue | semmle.label | [Label] #someValue | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | semmle.label | [NamespaceDeclaration] module ... } } | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | semmle.order | 59 | -| tst.ts:132:8:132:11 | [VarDecl] TS44 | semmle.label | [VarDecl] TS44 | -| tst.ts:133:3:138:3 | [FunctionDeclStmt] functio ... } } | semmle.label | [FunctionDeclStmt] functio ... } } | -| tst.ts:133:12:133:14 | [VarDecl] foo | semmle.label | [VarDecl] foo | -| tst.ts:133:16:133:18 | [SimpleParameter] arg | semmle.label | [SimpleParameter] arg | -| tst.ts:133:21:133:27 | [KeywordTypeExpr] unknown | semmle.label | [KeywordTypeExpr] unknown | -| tst.ts:133:30:138:3 | [BlockStmt] { c ... } } | semmle.label | [BlockStmt] { c ... } } | -| tst.ts:134:5:134:48 | [DeclStmt] const argIsString = ... | semmle.label | [DeclStmt] const argIsString = ... | -| tst.ts:134:11:134:21 | [VarDecl] argIsString | semmle.label | [VarDecl] argIsString | -| tst.ts:134:11:134:47 | [VariableDeclarator] argIsSt ... string" | semmle.label | [VariableDeclarator] argIsSt ... string" | -| tst.ts:134:25:134:34 | [UnaryExpr] typeof arg | semmle.label | [UnaryExpr] typeof arg | -| tst.ts:134:25:134:47 | [BinaryExpr] typeof ... string" | semmle.label | [BinaryExpr] typeof ... string" | -| tst.ts:134:32:134:34 | [VarRef] arg | semmle.label | [VarRef] arg | -| tst.ts:134:40:134:47 | [Literal] "string" | semmle.label | [Literal] "string" | -| tst.ts:135:5:137:5 | [IfStmt] if (arg ... ; } | semmle.label | [IfStmt] if (arg ... ; } | -| tst.ts:135:9:135:19 | [VarRef] argIsString | semmle.label | [VarRef] argIsString | -| tst.ts:135:22:137:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:136:9:136:40 | [DeclStmt] const upper = ... | semmle.label | [DeclStmt] const upper = ... | -| tst.ts:136:15:136:19 | [VarDecl] upper | semmle.label | [VarDecl] upper | -| tst.ts:136:15:136:39 | [VariableDeclarator] upper = ... rCase() | semmle.label | [VariableDeclarator] upper = ... rCase() | -| tst.ts:136:23:136:25 | [VarRef] arg | semmle.label | [VarRef] arg | -| tst.ts:136:23:136:37 | [DotExpr] arg.toUpperCase | semmle.label | [DotExpr] arg.toUpperCase | -| tst.ts:136:23:136:39 | [MethodCallExpr] arg.toUpperCase() | semmle.label | [MethodCallExpr] arg.toUpperCase() | -| tst.ts:136:27:136:37 | [Label] toUpperCase | semmle.label | [Label] toUpperCase | -| tst.ts:140:3:142:47 | [TypeAliasDeclaration,TypeDefinition] type Sh ... mber }; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Sh ... mber }; | -| tst.ts:140:8:140:12 | [Identifier] Shape | semmle.label | [Identifier] Shape | -| tst.ts:141:7:142:46 | [UnionTypeExpr] \| { kin ... umber } | semmle.label | [UnionTypeExpr] \| { kin ... umber } | -| tst.ts:141:9:141:42 | [InterfaceTypeExpr] { kind: ... umber } | semmle.label | [InterfaceTypeExpr] { kind: ... umber } | -| tst.ts:141:11:141:14 | [Label] kind | semmle.label | [Label] kind | -| tst.ts:141:11:141:25 | [FieldDeclaration] kind: "circle", | semmle.label | [FieldDeclaration] kind: "circle", | -| tst.ts:141:17:141:24 | [LiteralTypeExpr] "circle" | semmle.label | [LiteralTypeExpr] "circle" | -| tst.ts:141:27:141:32 | [Label] radius | semmle.label | [Label] radius | -| tst.ts:141:27:141:40 | [FieldDeclaration] radius: number | semmle.label | [FieldDeclaration] radius: number | -| tst.ts:141:35:141:40 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:142:9:142:46 | [InterfaceTypeExpr] { kind: ... umber } | semmle.label | [InterfaceTypeExpr] { kind: ... umber } | -| tst.ts:142:11:142:14 | [Label] kind | semmle.label | [Label] kind | -| tst.ts:142:11:142:25 | [FieldDeclaration] kind: "square", | semmle.label | [FieldDeclaration] kind: "square", | -| tst.ts:142:17:142:24 | [LiteralTypeExpr] "square" | semmle.label | [LiteralTypeExpr] "square" | -| tst.ts:142:27:142:36 | [Label] sideLength | semmle.label | [Label] sideLength | -| tst.ts:142:27:142:44 | [FieldDeclaration] sideLength: number | semmle.label | [FieldDeclaration] sideLength: number | -| tst.ts:142:39:142:44 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | semmle.label | [FunctionDeclStmt] functio ... ; } } | -| tst.ts:144:12:144:15 | [VarDecl] side | semmle.label | [VarDecl] side | -| tst.ts:144:17:144:21 | [SimpleParameter] shape | semmle.label | [SimpleParameter] shape | -| tst.ts:144:24:144:28 | [LocalTypeAccess] Shape | semmle.label | [LocalTypeAccess] Shape | -| tst.ts:144:32:144:37 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:144:39:149:3 | [BlockStmt] { ... ; } } | semmle.label | [BlockStmt] { ... ; } } | -| tst.ts:145:7:145:29 | [DeclStmt] const { ... shape; | semmle.label | [DeclStmt] const { ... shape; | -| tst.ts:145:13:145:20 | [ObjectPattern] { kind } | semmle.label | [ObjectPattern] { kind } | -| tst.ts:145:13:145:28 | [VariableDeclarator] { kind } = shape | semmle.label | [VariableDeclarator] { kind } = shape | -| tst.ts:145:15:145:18 | [Label] kind | semmle.label | [Label] kind | -| tst.ts:145:15:145:18 | [PropertyPattern] kind | semmle.label | [PropertyPattern] kind | -| tst.ts:145:15:145:18 | [VarDecl] kind | semmle.label | [VarDecl] kind | -| tst.ts:145:24:145:28 | [VarRef] shape | semmle.label | [VarRef] shape | -| tst.ts:147:7:148:39 | [IfStmt] if (kin ... ngth; } | semmle.label | [IfStmt] if (kin ... ngth; } | -| tst.ts:147:11:147:14 | [VarRef] kind | semmle.label | [VarRef] kind | -| tst.ts:147:11:147:27 | [BinaryExpr] kind === "circle" | semmle.label | [BinaryExpr] kind === "circle" | -| tst.ts:147:20:147:27 | [Literal] "circle" | semmle.label | [Literal] "circle" | -| tst.ts:147:30:147:52 | [BlockStmt] { retur ... adius;} | semmle.label | [BlockStmt] { retur ... adius;} | -| tst.ts:147:32:147:51 | [ReturnStmt] return shape.radius; | semmle.label | [ReturnStmt] return shape.radius; | -| tst.ts:147:39:147:43 | [VarRef] shape | semmle.label | [VarRef] shape | -| tst.ts:147:39:147:50 | [DotExpr] shape.radius | semmle.label | [DotExpr] shape.radius | -| tst.ts:147:45:147:50 | [Label] radius | semmle.label | [Label] radius | -| tst.ts:148:12:148:39 | [BlockStmt] { retur ... ngth; } | semmle.label | [BlockStmt] { retur ... ngth; } | -| tst.ts:148:14:148:37 | [ReturnStmt] return ... Length; | semmle.label | [ReturnStmt] return ... Length; | -| tst.ts:148:21:148:25 | [VarRef] shape | semmle.label | [VarRef] shape | -| tst.ts:148:21:148:36 | [DotExpr] shape.sideLength | semmle.label | [DotExpr] shape.sideLength | -| tst.ts:148:27:148:36 | [Label] sideLength | semmle.label | [Label] sideLength | -| tst.ts:151:3:162:3 | [FunctionDeclStmt] functio ... 2]; } | semmle.label | [FunctionDeclStmt] functio ... 2]; } | -| tst.ts:151:12:151:22 | [VarDecl] symbolIndex | semmle.label | [VarDecl] symbolIndex | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | semmle.label | [BlockStmt] { i ... 2]; } | -| tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | -| tst.ts:152:15:152:20 | [Identifier] Colors | semmle.label | [Identifier] Colors | -| tst.ts:153:7:153:28 | [FunctionExpr] [sym: s ... number; | semmle.label | [FunctionExpr] [sym: s ... number; | -| tst.ts:153:7:153:28 | [IndexSignature] [sym: s ... number; | semmle.label | [IndexSignature] [sym: s ... number; | -| tst.ts:153:8:153:10 | [SimpleParameter] sym | semmle.label | [SimpleParameter] sym | -| tst.ts:153:13:153:18 | [KeywordTypeExpr] symbol | semmle.label | [KeywordTypeExpr] symbol | -| tst.ts:153:22:153:27 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:154:7:154:28 | [FunctionExpr] [key: s ... string; | semmle.label | [FunctionExpr] [key: s ... string; | -| tst.ts:154:7:154:28 | [IndexSignature] [key: s ... string; | semmle.label | [IndexSignature] [key: s ... string; | -| tst.ts:154:8:154:10 | [SimpleParameter] key | semmle.label | [SimpleParameter] key | -| tst.ts:154:13:154:18 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:154:22:154:27 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:155:7:155:29 | [FunctionExpr] [num: n ... oolean; | semmle.label | [FunctionExpr] [num: n ... oolean; | -| tst.ts:155:7:155:29 | [IndexSignature] [num: n ... oolean; | semmle.label | [IndexSignature] [num: n ... oolean; | -| tst.ts:155:8:155:10 | [SimpleParameter] num | semmle.label | [SimpleParameter] num | -| tst.ts:155:13:155:18 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:155:22:155:28 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| tst.ts:158:5:158:28 | [DeclStmt] let colors = ... | semmle.label | [DeclStmt] let colors = ... | -| tst.ts:158:9:158:14 | [VarDecl] colors | semmle.label | [VarDecl] colors | -| tst.ts:158:9:158:27 | [VariableDeclarator] colors: Colors = {} | semmle.label | [VariableDeclarator] colors: Colors = {} | -| tst.ts:158:17:158:22 | [LocalTypeAccess] Colors | semmle.label | [LocalTypeAccess] Colors | -| tst.ts:158:26:158:27 | [ObjectExpr] {} | semmle.label | [ObjectExpr] {} | -| tst.ts:159:5:159:38 | [DeclStmt] const red = ... | semmle.label | [DeclStmt] const red = ... | -| tst.ts:159:11:159:13 | [VarDecl] red | semmle.label | [VarDecl] red | -| tst.ts:159:11:159:37 | [VariableDeclarator] red = c ... "red")] | semmle.label | [VariableDeclarator] red = c ... "red")] | -| tst.ts:159:17:159:22 | [VarRef] colors | semmle.label | [VarRef] colors | -| tst.ts:159:17:159:37 | [IndexExpr] colors[ ... "red")] | semmle.label | [IndexExpr] colors[ ... "red")] | -| tst.ts:159:24:159:29 | [VarRef] Symbol | semmle.label | [VarRef] Symbol | -| tst.ts:159:24:159:36 | [CallExpr] Symbol("red") | semmle.label | [CallExpr] Symbol("red") | -| tst.ts:159:31:159:35 | [Literal] "red" | semmle.label | [Literal] "red" | -| tst.ts:160:5:160:34 | [DeclStmt] const green = ... | semmle.label | [DeclStmt] const green = ... | -| tst.ts:160:11:160:15 | [VarDecl] green | semmle.label | [VarDecl] green | -| tst.ts:160:11:160:33 | [VariableDeclarator] green = ... green"] | semmle.label | [VariableDeclarator] green = ... green"] | -| tst.ts:160:19:160:24 | [VarRef] colors | semmle.label | [VarRef] colors | -| tst.ts:160:19:160:33 | [IndexExpr] colors["green"] | semmle.label | [IndexExpr] colors["green"] | -| tst.ts:160:26:160:32 | [Literal] "green" | semmle.label | [Literal] "green" | -| tst.ts:161:5:161:27 | [DeclStmt] const blue = ... | semmle.label | [DeclStmt] const blue = ... | -| tst.ts:161:11:161:14 | [VarDecl] blue | semmle.label | [VarDecl] blue | -| tst.ts:161:11:161:26 | [VariableDeclarator] blue = colors[2] | semmle.label | [VariableDeclarator] blue = colors[2] | -| tst.ts:161:18:161:23 | [VarRef] colors | semmle.label | [VarRef] colors | -| tst.ts:161:18:161:26 | [IndexExpr] colors[2] | semmle.label | [IndexExpr] colors[2] | -| tst.ts:161:25:161:25 | [Literal] 2 | semmle.label | [Literal] 2 | -| tst.ts:164:3:177:3 | [FunctionDeclStmt] functio ... "]; } | semmle.label | [FunctionDeclStmt] functio ... "]; } | -| tst.ts:164:12:164:29 | [VarDecl] stringPatternIndex | semmle.label | [VarDecl] stringPatternIndex | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | semmle.label | [BlockStmt] { i ... "]; } | -| tst.ts:165:5:167:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | -| tst.ts:165:15:165:17 | [Identifier] Foo | semmle.label | [Identifier] Foo | -| tst.ts:166:7:166:37 | [FunctionExpr] [key: ` ... number; | semmle.label | [FunctionExpr] [key: ` ... number; | -| tst.ts:166:7:166:37 | [IndexSignature] [key: ` ... number; | semmle.label | [IndexSignature] [key: ` ... number; | -| tst.ts:166:8:166:10 | [SimpleParameter] key | semmle.label | [SimpleParameter] key | -| tst.ts:166:13:166:27 | [TemplateLiteralTypeExpr] `foo-${number}` | semmle.label | [TemplateLiteralTypeExpr] `foo-${number}` | -| tst.ts:166:14:166:17 | [LiteralTypeExpr] foo- | semmle.label | [LiteralTypeExpr] foo- | -| tst.ts:166:20:166:25 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:166:31:166:36 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:168:5:168:23 | [DeclStmt] var bla = ... | semmle.label | [DeclStmt] var bla = ... | -| tst.ts:168:9:168:11 | [VarDecl] bla | semmle.label | [VarDecl] bla | -| tst.ts:168:9:168:22 | [VariableDeclarator] bla : Foo = {} | semmle.label | [VariableDeclarator] bla : Foo = {} | -| tst.ts:168:15:168:17 | [LocalTypeAccess] Foo | semmle.label | [LocalTypeAccess] Foo | -| tst.ts:168:21:168:22 | [ObjectExpr] {} | semmle.label | [ObjectExpr] {} | -| tst.ts:169:5:169:29 | [DeclStmt] const bar = ... | semmle.label | [DeclStmt] const bar = ... | -| tst.ts:169:11:169:13 | [VarDecl] bar | semmle.label | [VarDecl] bar | -| tst.ts:169:11:169:28 | [VariableDeclarator] bar = bla[`foo-1`] | semmle.label | [VariableDeclarator] bar = bla[`foo-1`] | -| tst.ts:169:17:169:19 | [VarRef] bla | semmle.label | [VarRef] bla | -| tst.ts:169:17:169:28 | [IndexExpr] bla[`foo-1`] | semmle.label | [IndexExpr] bla[`foo-1`] | -| tst.ts:169:21:169:27 | [TemplateElement] `foo-1` | semmle.label | [TemplateElement] `foo-1` | -| tst.ts:169:21:169:27 | [TemplateLiteral] `foo-1` | semmle.label | [TemplateLiteral] `foo-1` | -| tst.ts:171:5:173:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | -| tst.ts:171:15:171:18 | [Identifier] Data | semmle.label | [Identifier] Data | -| tst.ts:172:7:172:42 | [FunctionExpr] [optNam ... oolean; | semmle.label | [FunctionExpr] [optNam ... oolean; | -| tst.ts:172:7:172:42 | [IndexSignature] [optNam ... oolean; | semmle.label | [IndexSignature] [optNam ... oolean; | -| tst.ts:172:8:172:14 | [SimpleParameter] optName | semmle.label | [SimpleParameter] optName | -| tst.ts:172:17:172:22 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:172:17:172:31 | [UnionTypeExpr] string \| symbol | semmle.label | [UnionTypeExpr] string \| symbol | -| tst.ts:172:26:172:31 | [KeywordTypeExpr] symbol | semmle.label | [KeywordTypeExpr] symbol | -| tst.ts:172:35:172:41 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| tst.ts:175:5:175:26 | [DeclStmt] const data = ... | semmle.label | [DeclStmt] const data = ... | -| tst.ts:175:11:175:14 | [VarDecl] data | semmle.label | [VarDecl] data | -| tst.ts:175:11:175:25 | [VariableDeclarator] data: Data = {} | semmle.label | [VariableDeclarator] data: Data = {} | -| tst.ts:175:17:175:20 | [LocalTypeAccess] Data | semmle.label | [LocalTypeAccess] Data | -| tst.ts:175:24:175:25 | [ObjectExpr] {} | semmle.label | [ObjectExpr] {} | -| tst.ts:176:5:176:28 | [DeclStmt] const baz = ... | semmle.label | [DeclStmt] const baz = ... | -| tst.ts:176:11:176:13 | [VarDecl] baz | semmle.label | [VarDecl] baz | -| tst.ts:176:11:176:27 | [VariableDeclarator] baz = data["foo"] | semmle.label | [VariableDeclarator] baz = data["foo"] | -| tst.ts:176:17:176:20 | [VarRef] data | semmle.label | [VarRef] data | -| tst.ts:176:17:176:27 | [IndexExpr] data["foo"] | semmle.label | [IndexExpr] data["foo"] | -| tst.ts:176:22:176:26 | [Literal] "foo" | semmle.label | [Literal] "foo" | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | semmle.label | [ClassDefinition,TypeDefinition] class F ... } | -| tst.ts:179:9:179:11 | [VarDecl] Foo | semmle.label | [VarDecl] Foo | -| tst.ts:179:13:179:12 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:179:13:179:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | [ClassInitializedMember,ConstructorDefinition] constructor() {} | -| tst.ts:179:13:179:12 | [FunctionExpr] () {} | semmle.label | [FunctionExpr] () {} | -| tst.ts:179:13:179:12 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:180:5:180:22 | [ClassInitializedMember,FieldDeclaration] static #count = 0; | semmle.label | [ClassInitializedMember,FieldDeclaration] static #count = 0; | -| tst.ts:180:12:180:17 | [Label] #count | semmle.label | [Label] #count | -| tst.ts:180:21:180:21 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:182:5:184:5 | [ClassInitializedMember,GetterMethodDefinition] get cou ... ; } | semmle.label | [ClassInitializedMember,GetterMethodDefinition] get cou ... ; } | -| tst.ts:182:5:184:5 | [FunctionExpr] get cou ... ; } | semmle.label | [FunctionExpr] get cou ... ; } | -| tst.ts:182:9:182:13 | [Label] count | semmle.label | [Label] count | -| tst.ts:182:17:184:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:183:9:183:26 | [ReturnStmt] return Foo.#count; | semmle.label | [ReturnStmt] return Foo.#count; | -| tst.ts:183:16:183:18 | [VarRef] Foo | semmle.label | [VarRef] Foo | -| tst.ts:183:16:183:25 | [DotExpr] Foo.#count | semmle.label | [DotExpr] Foo.#count | -| tst.ts:183:20:183:25 | [Label] #count | semmle.label | [Label] #count | -| tst.ts:185:5:187:5 | [BlockStmt] static ... ; } | semmle.label | [BlockStmt] static ... ; } | -| tst.ts:185:5:187:5 | [ClassInitializedMember] static ... ; } | semmle.label | [ClassInitializedMember] static ... ; } | -| tst.ts:186:7:186:9 | [VarRef] Foo | semmle.label | [VarRef] Foo | -| tst.ts:186:7:186:16 | [DotExpr] Foo.#count | semmle.label | [DotExpr] Foo.#count | -| tst.ts:186:7:186:21 | [CompoundAssignExpr] Foo.#count += 3 | semmle.label | [CompoundAssignExpr] Foo.#count += 3 | -| tst.ts:186:7:186:22 | [ExprStmt] Foo.#count += 3; | semmle.label | [ExprStmt] Foo.#count += 3; | -| tst.ts:186:11:186:16 | [Label] #count | semmle.label | [Label] #count | -| tst.ts:186:21:186:21 | [Literal] 3 | semmle.label | [Literal] 3 | -| tst.ts:188:5:190:5 | [BlockStmt] static ... ; } | semmle.label | [BlockStmt] static ... ; } | -| tst.ts:188:5:190:5 | [ClassInitializedMember] static ... ; } | semmle.label | [ClassInitializedMember] static ... ; } | -| tst.ts:189:7:189:29 | [DeclStmt] var count = ... | semmle.label | [DeclStmt] var count = ... | -| tst.ts:189:11:189:15 | [VarDecl] count | semmle.label | [VarDecl] count | -| tst.ts:189:11:189:28 | [VariableDeclarator] count = Foo.#count | semmle.label | [VariableDeclarator] count = Foo.#count | -| tst.ts:189:19:189:21 | [VarRef] Foo | semmle.label | [VarRef] Foo | -| tst.ts:189:19:189:28 | [DotExpr] Foo.#count | semmle.label | [DotExpr] Foo.#count | -| tst.ts:189:23:189:28 | [Label] #count | semmle.label | [Label] #count | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | semmle.label | [NamespaceDeclaration] module ... } } } | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | semmle.order | 60 | -| tst.ts:195:8:195:11 | [VarDecl] TS45 | semmle.label | [VarDecl] TS45 | -| tst.ts:197:3:197:36 | [TypeAliasDeclaration,TypeDefinition] type A ... ring>>; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type A ... ring>>; | -| tst.ts:197:8:197:8 | [Identifier] A | semmle.label | [Identifier] A | -| tst.ts:197:12:197:18 | [LocalTypeAccess] Awaited | semmle.label | [LocalTypeAccess] Awaited | -| tst.ts:197:12:197:35 | [GenericTypeExpr] Awaited ... tring>> | semmle.label | [GenericTypeExpr] Awaited ... tring>> | -| tst.ts:197:20:197:26 | [LocalTypeAccess] Promise | semmle.label | [LocalTypeAccess] Promise | -| tst.ts:197:20:197:34 | [GenericTypeExpr] Promise | semmle.label | [GenericTypeExpr] Promise | -| tst.ts:197:28:197:33 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:200:3:200:45 | [TypeAliasDeclaration,TypeDefinition] type B ... ber>>>; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type B ... ber>>>; | -| tst.ts:200:8:200:8 | [Identifier] B | semmle.label | [Identifier] B | -| tst.ts:200:12:200:18 | [LocalTypeAccess] Awaited | semmle.label | [LocalTypeAccess] Awaited | -| tst.ts:200:12:200:44 | [GenericTypeExpr] Awaited ... mber>>> | semmle.label | [GenericTypeExpr] Awaited ... mber>>> | -| tst.ts:200:20:200:26 | [LocalTypeAccess] Promise | semmle.label | [LocalTypeAccess] Promise | -| tst.ts:200:20:200:43 | [GenericTypeExpr] Promise ... umber>> | semmle.label | [GenericTypeExpr] Promise ... umber>> | -| tst.ts:200:28:200:34 | [LocalTypeAccess] Promise | semmle.label | [LocalTypeAccess] Promise | -| tst.ts:200:28:200:42 | [GenericTypeExpr] Promise | semmle.label | [GenericTypeExpr] Promise | -| tst.ts:200:36:200:41 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:203:3:203:46 | [TypeAliasDeclaration,TypeDefinition] type C ... mber>>; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type C ... mber>>; | -| tst.ts:203:8:203:8 | [Identifier] C | semmle.label | [Identifier] C | -| tst.ts:203:12:203:18 | [LocalTypeAccess] Awaited | semmle.label | [LocalTypeAccess] Awaited | -| tst.ts:203:12:203:45 | [GenericTypeExpr] Awaited ... umber>> | semmle.label | [GenericTypeExpr] Awaited ... umber>> | -| tst.ts:203:20:203:26 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| tst.ts:203:20:203:44 | [UnionTypeExpr] boolean ... number> | semmle.label | [UnionTypeExpr] boolean ... number> | -| tst.ts:203:30:203:36 | [LocalTypeAccess] Promise | semmle.label | [LocalTypeAccess] Promise | -| tst.ts:203:30:203:44 | [GenericTypeExpr] Promise | semmle.label | [GenericTypeExpr] Promise | -| tst.ts:203:38:203:43 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:205:3:208:3 | [ExportDeclaration] export ... ng; } | semmle.label | [ExportDeclaration] export ... ng; } | -| tst.ts:205:10:208:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | -| tst.ts:205:20:205:26 | [Identifier] Success | semmle.label | [Identifier] Success | -| tst.ts:206:5:206:8 | [Label] type | semmle.label | [Label] type | -| tst.ts:206:5:206:29 | [FieldDeclaration] type: ` ... ccess`; | semmle.label | [FieldDeclaration] type: ` ... ccess`; | -| tst.ts:206:11:206:28 | [TemplateLiteralTypeExpr] `${string}Success` | semmle.label | [TemplateLiteralTypeExpr] `${string}Success` | -| tst.ts:206:14:206:19 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:206:21:206:27 | [LiteralTypeExpr] Success | semmle.label | [LiteralTypeExpr] Success | -| tst.ts:207:5:207:8 | [Label] body | semmle.label | [Label] body | -| tst.ts:207:5:207:17 | [FieldDeclaration] body: string; | semmle.label | [FieldDeclaration] body: string; | -| tst.ts:207:11:207:16 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:210:3:213:3 | [ExportDeclaration] export ... ng; } | semmle.label | [ExportDeclaration] export ... ng; } | -| tst.ts:210:10:213:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | -| tst.ts:210:20:210:24 | [Identifier] Error | semmle.label | [Identifier] Error | -| tst.ts:211:7:211:10 | [Label] type | semmle.label | [Label] type | -| tst.ts:211:7:211:29 | [FieldDeclaration] type: ` ... Error`; | semmle.label | [FieldDeclaration] type: ` ... Error`; | -| tst.ts:211:13:211:28 | [TemplateLiteralTypeExpr] `${string}Error` | semmle.label | [TemplateLiteralTypeExpr] `${string}Error` | -| tst.ts:211:16:211:21 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:211:23:211:27 | [LiteralTypeExpr] Error | semmle.label | [LiteralTypeExpr] Error | -| tst.ts:212:7:212:13 | [Label] message | semmle.label | [Label] message | -| tst.ts:212:7:212:22 | [FieldDeclaration] message: string; | semmle.label | [FieldDeclaration] message: string; | -| tst.ts:212:16:212:21 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:215:3:220:3 | [ExportDeclaration] export ... } } | semmle.label | [ExportDeclaration] export ... } } | -| tst.ts:215:10:220:3 | [FunctionDeclStmt] functio ... } } | semmle.label | [FunctionDeclStmt] functio ... } } | -| tst.ts:215:19:215:25 | [VarDecl] handler | semmle.label | [VarDecl] handler | -| tst.ts:215:27:215:27 | [SimpleParameter] r | semmle.label | [SimpleParameter] r | -| tst.ts:215:30:215:36 | [LocalTypeAccess] Success | semmle.label | [LocalTypeAccess] Success | -| tst.ts:215:30:215:44 | [UnionTypeExpr] Success \| Error | semmle.label | [UnionTypeExpr] Success \| Error | -| tst.ts:215:40:215:44 | [LocalTypeAccess] Error | semmle.label | [LocalTypeAccess] Error | -| tst.ts:215:47:220:3 | [BlockStmt] { ... } } | semmle.label | [BlockStmt] { ... } } | -| tst.ts:216:7:219:7 | [IfStmt] if (r.t ... } | semmle.label | [IfStmt] if (r.t ... } | -| tst.ts:216:11:216:11 | [VarRef] r | semmle.label | [VarRef] r | -| tst.ts:216:11:216:16 | [DotExpr] r.type | semmle.label | [DotExpr] r.type | -| tst.ts:216:11:216:34 | [BinaryExpr] r.type ... uccess" | semmle.label | [BinaryExpr] r.type ... uccess" | -| tst.ts:216:13:216:16 | [Label] type | semmle.label | [Label] type | -| tst.ts:216:22:216:34 | [Literal] "HttpSuccess" | semmle.label | [Literal] "HttpSuccess" | -| tst.ts:216:37:219:7 | [BlockStmt] { ... } | semmle.label | [BlockStmt] { ... } | -| tst.ts:218:11:218:29 | [DeclStmt] let token = ... | semmle.label | [DeclStmt] let token = ... | -| tst.ts:218:15:218:19 | [VarDecl] token | semmle.label | [VarDecl] token | -| tst.ts:218:15:218:28 | [VariableDeclarator] token = r.body | semmle.label | [VariableDeclarator] token = r.body | -| tst.ts:218:23:218:23 | [VarRef] r | semmle.label | [VarRef] r | -| tst.ts:218:23:218:28 | [DotExpr] r.body | semmle.label | [DotExpr] r.body | -| tst.ts:218:25:218:28 | [Label] body | semmle.label | [Label] body | -| tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | semmle.label | [ClassDefinition,TypeDefinition] class P ... } } | -| tst.ts:222:9:222:14 | [VarDecl] Person | semmle.label | [VarDecl] Person | -| tst.ts:223:5:223:9 | [Label] #name | semmle.label | [Label] #name | -| tst.ts:223:5:223:18 | [FieldDeclaration] #name: string; | semmle.label | [FieldDeclaration] #name: string; | -| tst.ts:223:12:223:17 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:224:5:226:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | semmle.label | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | -| tst.ts:224:5:226:5 | [FunctionExpr] constru ... ; } | semmle.label | [FunctionExpr] constru ... ; } | -| tst.ts:224:5:226:5 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:224:17:224:20 | [SimpleParameter] name | semmle.label | [SimpleParameter] name | -| tst.ts:224:23:224:28 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:224:31:226:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:225:9:225:12 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:225:9:225:18 | [DotExpr] this.#name | semmle.label | [DotExpr] this.#name | -| tst.ts:225:9:225:25 | [AssignExpr] this.#name = name | semmle.label | [AssignExpr] this.#name = name | -| tst.ts:225:9:225:26 | [ExprStmt] this.#name = name; | semmle.label | [ExprStmt] this.#name = name; | -| tst.ts:225:14:225:18 | [Label] #name | semmle.label | [Label] #name | -| tst.ts:225:22:225:25 | [VarRef] name | semmle.label | [VarRef] name | -| tst.ts:228:5:228:10 | [Label] equals | semmle.label | [Label] equals | -| tst.ts:228:5:233:5 | [ClassInitializedMember,MethodDefinition] equals( ... . } | semmle.label | [ClassInitializedMember,MethodDefinition] equals( ... . } | -| tst.ts:228:5:233:5 | [FunctionExpr] equals( ... . } | semmle.label | [FunctionExpr] equals( ... . } | -| tst.ts:228:12:228:16 | [SimpleParameter] other | semmle.label | [SimpleParameter] other | -| tst.ts:228:19:228:25 | [KeywordTypeExpr] unknown | semmle.label | [KeywordTypeExpr] unknown | -| tst.ts:228:28:233:5 | [BlockStmt] { ... . } | semmle.label | [BlockStmt] { ... . } | -| tst.ts:229:9:232:39 | [ReturnStmt] return ... .#name; | semmle.label | [ReturnStmt] return ... .#name; | -| tst.ts:229:16:229:20 | [VarRef] other | semmle.label | [VarRef] other | -| tst.ts:229:16:230:37 | [BinaryExpr] other & ... object" | semmle.label | [BinaryExpr] other & ... object" | -| tst.ts:229:16:231:26 | [BinaryExpr] other & ... n other | semmle.label | [BinaryExpr] other & ... n other | -| tst.ts:229:16:232:38 | [BinaryExpr] other & ... r.#name | semmle.label | [BinaryExpr] other & ... r.#name | -| tst.ts:230:13:230:24 | [UnaryExpr] typeof other | semmle.label | [UnaryExpr] typeof other | -| tst.ts:230:13:230:37 | [BinaryExpr] typeof ... object" | semmle.label | [BinaryExpr] typeof ... object" | -| tst.ts:230:20:230:24 | [VarRef] other | semmle.label | [VarRef] other | -| tst.ts:230:30:230:37 | [Literal] "object" | semmle.label | [Literal] "object" | -| tst.ts:231:13:231:17 | [Label] #name | semmle.label | [Label] #name | -| tst.ts:231:13:231:26 | [BinaryExpr] #name in other | semmle.label | [BinaryExpr] #name in other | -| tst.ts:231:22:231:26 | [VarRef] other | semmle.label | [VarRef] other | -| tst.ts:232:13:232:16 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:232:13:232:22 | [DotExpr] this.#name | semmle.label | [DotExpr] this.#name | -| tst.ts:232:13:232:38 | [BinaryExpr] this.#n ... r.#name | semmle.label | [BinaryExpr] this.#n ... r.#name | -| tst.ts:232:18:232:22 | [Label] #name | semmle.label | [Label] #name | -| tst.ts:232:28:232:32 | [VarRef] other | semmle.label | [VarRef] other | -| tst.ts:232:28:232:38 | [DotExpr] other.#name | semmle.label | [DotExpr] other.#name | -| tst.ts:232:34:232:38 | [Label] #name | semmle.label | [Label] #name | -| tst.ts:237:1:237:63 | [ImportDeclaration] import ... son" }; | semmle.label | [ImportDeclaration] import ... son" }; | -| tst.ts:237:1:237:63 | [ImportDeclaration] import ... son" }; | semmle.order | 61 | -| tst.ts:237:8:237:16 | [ImportSpecifier] * as Foo3 | semmle.label | [ImportSpecifier] * as Foo3 | -| tst.ts:237:13:237:16 | [VarDecl] Foo3 | semmle.label | [VarDecl] Foo3 | -| tst.ts:237:23:237:40 | [Literal] "./something.json" | semmle.label | [Literal] "./something.json" | -| tst.ts:237:47:237:62 | [ObjectExpr] { type: "json" } | semmle.label | [ObjectExpr] { type: "json" } | -| tst.ts:237:49:237:60 | [Property] type: "json" | semmle.label | [Property] type: "json" | -| tst.ts:238:1:238:19 | [DeclStmt] var foo = ... | semmle.label | [DeclStmt] var foo = ... | -| tst.ts:238:1:238:19 | [DeclStmt] var foo = ... | semmle.order | 62 | -| tst.ts:238:5:238:7 | [VarDecl] foo | semmle.label | [VarDecl] foo | -| tst.ts:238:5:238:18 | [VariableDeclarator] foo = Foo3.foo | semmle.label | [VariableDeclarator] foo = Foo3.foo | -| tst.ts:238:11:238:14 | [VarRef] Foo3 | semmle.label | [VarRef] Foo3 | -| tst.ts:238:11:238:18 | [DotExpr] Foo3.foo | semmle.label | [DotExpr] Foo3.foo | -| tst.ts:238:16:238:18 | [Label] foo | semmle.label | [Label] foo | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | semmle.label | [NamespaceDeclaration] module ... }; } | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | semmle.order | 63 | -| tst.ts:240:8:240:11 | [VarDecl] TS46 | semmle.label | [VarDecl] TS46 | -| tst.ts:241:3:241:15 | [ClassDefinition,TypeDefinition] class Base {} | semmle.label | [ClassDefinition,TypeDefinition] class Base {} | -| tst.ts:241:9:241:12 | [VarDecl] Base | semmle.label | [VarDecl] Base | -| tst.ts:241:14:241:13 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:241:14:241:13 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | [ClassInitializedMember,ConstructorDefinition] constructor() {} | -| tst.ts:241:14:241:13 | [FunctionExpr] () {} | semmle.label | [FunctionExpr] () {} | -| tst.ts:241:14:241:13 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | semmle.label | [ClassDefinition,TypeDefinition] class D ... } } | -| tst.ts:243:9:243:15 | [VarDecl] Derived | semmle.label | [VarDecl] Derived | -| tst.ts:243:25:243:28 | [VarRef] Base | semmle.label | [VarRef] Base | -| tst.ts:244:5:244:10 | [Label] myProp | semmle.label | [Label] myProp | -| tst.ts:244:5:244:18 | [FieldDeclaration] myProp = true; | semmle.label | [FieldDeclaration] myProp = true; | -| tst.ts:244:14:244:17 | [Literal] true | semmle.label | [Literal] true | -| tst.ts:246:5:249:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | semmle.label | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | -| tst.ts:246:5:249:5 | [FunctionExpr] constru ... ; } | semmle.label | [FunctionExpr] constru ... ; } | -| tst.ts:246:5:249:5 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:246:19:249:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:247:7:247:13 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:247:7:247:17 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:247:7:247:51 | [MethodCallExpr] console ... per()") | semmle.label | [MethodCallExpr] console ... per()") | -| tst.ts:247:7:247:52 | [ExprStmt] console ... er()"); | semmle.label | [ExprStmt] console ... er()"); | -| tst.ts:247:15:247:17 | [Label] log | semmle.label | [Label] log | -| tst.ts:247:19:247:50 | [Literal] "Doing something before super()" | semmle.label | [Literal] "Doing something before super()" | -| tst.ts:248:7:248:11 | [SuperExpr] super | semmle.label | [SuperExpr] super | -| tst.ts:248:7:248:13 | [CallExpr] super() | semmle.label | [CallExpr] super() | -| tst.ts:248:7:248:14 | [ExprStmt] super(); | semmle.label | [ExprStmt] super(); | -| tst.ts:252:3:254:50 | [TypeAliasDeclaration,TypeDefinition] type Ac ... ring }; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Ac ... ring }; | -| tst.ts:252:8:252:13 | [Identifier] Action | semmle.label | [Identifier] Action | -| tst.ts:253:5:254:49 | [UnionTypeExpr] \| { kin ... tring } | semmle.label | [UnionTypeExpr] \| { kin ... tring } | -| tst.ts:253:7:253:49 | [InterfaceTypeExpr] { kind: ... umber } | semmle.label | [InterfaceTypeExpr] { kind: ... umber } | -| tst.ts:253:9:253:12 | [Label] kind | semmle.label | [Label] kind | -| tst.ts:253:9:253:31 | [FieldDeclaration] kind: " ... tents"; | semmle.label | [FieldDeclaration] kind: " ... tents"; | -| tst.ts:253:15:253:30 | [LiteralTypeExpr] "NumberContents" | semmle.label | [LiteralTypeExpr] "NumberContents" | -| tst.ts:253:33:253:39 | [Label] payload | semmle.label | [Label] payload | -| tst.ts:253:33:253:47 | [FieldDeclaration] payload: number | semmle.label | [FieldDeclaration] payload: number | -| tst.ts:253:42:253:47 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:254:7:254:49 | [InterfaceTypeExpr] { kind: ... tring } | semmle.label | [InterfaceTypeExpr] { kind: ... tring } | -| tst.ts:254:9:254:12 | [Label] kind | semmle.label | [Label] kind | -| tst.ts:254:9:254:31 | [FieldDeclaration] kind: " ... tents"; | semmle.label | [FieldDeclaration] kind: " ... tents"; | -| tst.ts:254:15:254:30 | [LiteralTypeExpr] "StringContents" | semmle.label | [LiteralTypeExpr] "StringContents" | -| tst.ts:254:33:254:39 | [Label] payload | semmle.label | [Label] payload | -| tst.ts:254:33:254:47 | [FieldDeclaration] payload: string | semmle.label | [FieldDeclaration] payload: string | -| tst.ts:254:42:254:47 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:256:3:263:3 | [FunctionDeclStmt] functio ... } } | semmle.label | [FunctionDeclStmt] functio ... } } | -| tst.ts:256:12:256:24 | [VarDecl] processAction | semmle.label | [VarDecl] processAction | -| tst.ts:256:26:256:31 | [SimpleParameter] action | semmle.label | [SimpleParameter] action | -| tst.ts:256:34:256:39 | [LocalTypeAccess] Action | semmle.label | [LocalTypeAccess] Action | -| tst.ts:256:42:263:3 | [BlockStmt] { c ... } } | semmle.label | [BlockStmt] { c ... } } | -| tst.ts:257:5:257:37 | [DeclStmt] const { ... action; | semmle.label | [DeclStmt] const { ... action; | -| tst.ts:257:11:257:27 | [ObjectPattern] { kind, payload } | semmle.label | [ObjectPattern] { kind, payload } | -| tst.ts:257:11:257:36 | [VariableDeclarator] { kind, ... action | semmle.label | [VariableDeclarator] { kind, ... action | -| tst.ts:257:13:257:16 | [Label] kind | semmle.label | [Label] kind | -| tst.ts:257:13:257:16 | [PropertyPattern] kind | semmle.label | [PropertyPattern] kind | -| tst.ts:257:13:257:16 | [VarDecl] kind | semmle.label | [VarDecl] kind | -| tst.ts:257:19:257:25 | [Label] payload | semmle.label | [Label] payload | -| tst.ts:257:19:257:25 | [PropertyPattern] payload | semmle.label | [PropertyPattern] payload | -| tst.ts:257:19:257:25 | [VarDecl] payload | semmle.label | [VarDecl] payload | -| tst.ts:257:31:257:36 | [VarRef] action | semmle.label | [VarRef] action | -| tst.ts:258:5:262:5 | [IfStmt] if (kin ... g } | semmle.label | [IfStmt] if (kin ... g } | -| tst.ts:258:9:258:12 | [VarRef] kind | semmle.label | [VarRef] kind | -| tst.ts:258:9:258:33 | [BinaryExpr] kind == ... ntents" | semmle.label | [BinaryExpr] kind == ... ntents" | -| tst.ts:258:18:258:33 | [Literal] "NumberContents" | semmle.label | [Literal] "NumberContents" | -| tst.ts:258:36:260:5 | [BlockStmt] { ... r } | semmle.label | [BlockStmt] { ... r } | -| tst.ts:259:7:259:13 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:259:7:259:17 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:259:7:259:36 | [MethodCallExpr] console ... ixed()) | semmle.label | [MethodCallExpr] console ... ixed()) | -| tst.ts:259:7:259:37 | [ExprStmt] console ... xed()); | semmle.label | [ExprStmt] console ... xed()); | -| tst.ts:259:15:259:17 | [Label] log | semmle.label | [Label] log | -| tst.ts:259:19:259:25 | [VarRef] payload | semmle.label | [VarRef] payload | -| tst.ts:259:19:259:33 | [DotExpr] payload.toFixed | semmle.label | [DotExpr] payload.toFixed | -| tst.ts:259:19:259:35 | [MethodCallExpr] payload.toFixed() | semmle.label | [MethodCallExpr] payload.toFixed() | -| tst.ts:259:27:259:33 | [Label] toFixed | semmle.label | [Label] toFixed | -| tst.ts:260:12:262:5 | [IfStmt] if (kin ... g } | semmle.label | [IfStmt] if (kin ... g } | -| tst.ts:260:16:260:19 | [VarRef] kind | semmle.label | [VarRef] kind | -| tst.ts:260:16:260:40 | [BinaryExpr] kind == ... ntents" | semmle.label | [BinaryExpr] kind == ... ntents" | -| tst.ts:260:25:260:40 | [Literal] "StringContents" | semmle.label | [Literal] "StringContents" | -| tst.ts:260:43:262:5 | [BlockStmt] { ... g } | semmle.label | [BlockStmt] { ... g } | -| tst.ts:261:7:261:13 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:261:7:261:17 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:261:7:261:40 | [MethodCallExpr] console ... Case()) | semmle.label | [MethodCallExpr] console ... Case()) | -| tst.ts:261:7:261:41 | [ExprStmt] console ... ase()); | semmle.label | [ExprStmt] console ... ase()); | -| tst.ts:261:15:261:17 | [Label] log | semmle.label | [Label] log | -| tst.ts:261:19:261:25 | [VarRef] payload | semmle.label | [VarRef] payload | -| tst.ts:261:19:261:37 | [DotExpr] payload.toLowerCase | semmle.label | [DotExpr] payload.toLowerCase | -| tst.ts:261:19:261:39 | [MethodCallExpr] payload ... rCase() | semmle.label | [MethodCallExpr] payload ... rCase() | -| tst.ts:261:27:261:37 | [Label] toLowerCase | semmle.label | [Label] toLowerCase | -| tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | -| tst.ts:265:13:265:19 | [Identifier] TypeMap | semmle.label | [Identifier] TypeMap | -| tst.ts:266:5:266:10 | [Label] number | semmle.label | [Label] number | -| tst.ts:266:5:266:19 | [FieldDeclaration] number: number; | semmle.label | [FieldDeclaration] number: number; | -| tst.ts:266:13:266:18 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:267:5:267:10 | [Label] string | semmle.label | [Label] string | -| tst.ts:267:5:267:19 | [FieldDeclaration] string: string; | semmle.label | [FieldDeclaration] string: string; | -| tst.ts:267:13:267:18 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:268:5:268:11 | [Label] boolean | semmle.label | [Label] boolean | -| tst.ts:268:5:268:21 | [FieldDeclaration] boolean: boolean; | semmle.label | [FieldDeclaration] boolean: boolean; | -| tst.ts:268:14:268:20 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| tst.ts:271:3:276:7 | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | -| tst.ts:271:8:271:18 | [Identifier] UnionRecord | semmle.label | [Identifier] UnionRecord | -| tst.ts:271:20:271:20 | [Identifier] P | semmle.label | [Identifier] P | -| tst.ts:271:20:271:42 | [TypeParameter] P exten ... TypeMap | semmle.label | [TypeParameter] P exten ... TypeMap | -| tst.ts:271:30:271:42 | [KeyofTypeExpr] keyof TypeMap | semmle.label | [KeyofTypeExpr] keyof TypeMap | -| tst.ts:271:36:271:42 | [LocalTypeAccess] TypeMap | semmle.label | [LocalTypeAccess] TypeMap | -| tst.ts:271:47:276:3 | [MappedTypeExpr] { [ ... }; } | semmle.label | [MappedTypeExpr] { [ ... }; } | -| tst.ts:271:47:276:6 | [IndexedAccessTypeExpr] { [ ... }[P] | semmle.label | [IndexedAccessTypeExpr] { [ ... }[P] | -| tst.ts:272:6:272:6 | [Identifier] K | semmle.label | [Identifier] K | -| tst.ts:272:6:272:11 | [TypeParameter] K in P | semmle.label | [TypeParameter] K in P | -| tst.ts:272:11:272:11 | [LocalTypeAccess] P | semmle.label | [LocalTypeAccess] P | -| tst.ts:272:15:275:5 | [InterfaceTypeExpr] { ... ; } | semmle.label | [InterfaceTypeExpr] { ... ; } | -| tst.ts:273:7:273:10 | [Label] kind | semmle.label | [Label] kind | -| tst.ts:273:7:273:14 | [FieldDeclaration] kind: K; | semmle.label | [FieldDeclaration] kind: K; | -| tst.ts:273:13:273:13 | [LocalTypeAccess] K | semmle.label | [LocalTypeAccess] K | -| tst.ts:274:7:274:7 | [Label] f | semmle.label | [Label] f | -| tst.ts:274:7:274:33 | [FieldDeclaration] f: (p: ... > void; | semmle.label | [FieldDeclaration] f: (p: ... > void; | -| tst.ts:274:10:274:32 | [FunctionExpr] (p: Typ ... => void | semmle.label | [FunctionExpr] (p: Typ ... => void | -| tst.ts:274:10:274:32 | [FunctionTypeExpr] (p: Typ ... => void | semmle.label | [FunctionTypeExpr] (p: Typ ... => void | -| tst.ts:274:11:274:11 | [SimpleParameter] p | semmle.label | [SimpleParameter] p | -| tst.ts:274:14:274:20 | [LocalTypeAccess] TypeMap | semmle.label | [LocalTypeAccess] TypeMap | -| tst.ts:274:14:274:23 | [IndexedAccessTypeExpr] TypeMap[K] | semmle.label | [IndexedAccessTypeExpr] TypeMap[K] | -| tst.ts:274:22:274:22 | [LocalTypeAccess] K | semmle.label | [LocalTypeAccess] K | -| tst.ts:274:29:274:32 | [KeywordTypeExpr] void | semmle.label | [KeywordTypeExpr] void | -| tst.ts:276:5:276:5 | [LocalTypeAccess] P | semmle.label | [LocalTypeAccess] P | -| tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | semmle.label | [FunctionDeclStmt] functio ... v); } | -| tst.ts:278:12:278:24 | [VarDecl] processRecord | semmle.label | [VarDecl] processRecord | -| tst.ts:278:26:278:26 | [Identifier] K | semmle.label | [Identifier] K | -| tst.ts:278:26:278:48 | [TypeParameter] K exten ... TypeMap | semmle.label | [TypeParameter] K exten ... TypeMap | -| tst.ts:278:36:278:48 | [KeyofTypeExpr] keyof TypeMap | semmle.label | [KeyofTypeExpr] keyof TypeMap | -| tst.ts:278:42:278:48 | [LocalTypeAccess] TypeMap | semmle.label | [LocalTypeAccess] TypeMap | -| tst.ts:278:51:278:56 | [SimpleParameter] record | semmle.label | [SimpleParameter] record | -| tst.ts:278:59:278:69 | [LocalTypeAccess] UnionRecord | semmle.label | [LocalTypeAccess] UnionRecord | -| tst.ts:278:59:278:72 | [GenericTypeExpr] UnionRecord | semmle.label | [GenericTypeExpr] UnionRecord | -| tst.ts:278:71:278:71 | [LocalTypeAccess] K | semmle.label | [LocalTypeAccess] K | -| tst.ts:278:75:280:3 | [BlockStmt] { r ... v); } | semmle.label | [BlockStmt] { r ... v); } | -| tst.ts:279:5:279:10 | [VarRef] record | semmle.label | [VarRef] record | -| tst.ts:279:5:279:12 | [DotExpr] record.f | semmle.label | [DotExpr] record.f | -| tst.ts:279:5:279:22 | [MethodCallExpr] record.f(record.v) | semmle.label | [MethodCallExpr] record.f(record.v) | -| tst.ts:279:5:279:23 | [ExprStmt] record.f(record.v); | semmle.label | [ExprStmt] record.f(record.v); | -| tst.ts:279:12:279:12 | [Label] f | semmle.label | [Label] f | -| tst.ts:279:14:279:19 | [VarRef] record | semmle.label | [VarRef] record | -| tst.ts:279:14:279:21 | [DotExpr] record.v | semmle.label | [DotExpr] record.v | -| tst.ts:279:21:279:21 | [Label] v | semmle.label | [Label] v | -| tst.ts:282:3:282:15 | [VarRef] processRecord | semmle.label | [VarRef] processRecord | -| tst.ts:282:3:287:4 | [CallExpr] process ... }, }) | semmle.label | [CallExpr] process ... }, }) | -| tst.ts:282:3:287:5 | [ExprStmt] process ... , }); | semmle.label | [ExprStmt] process ... , }); | -| tst.ts:282:17:287:3 | [ObjectExpr] {kind: ...} | semmle.label | [ObjectExpr] {kind: ...} | -| tst.ts:283:5:283:8 | [Label] kind | semmle.label | [Label] kind | -| tst.ts:283:5:283:18 | [Property] kind: "string" | semmle.label | [Property] kind: "string" | -| tst.ts:283:11:283:18 | [Literal] "string" | semmle.label | [Literal] "string" | -| tst.ts:284:5:284:5 | [Label] f | semmle.label | [Label] f | -| tst.ts:284:5:286:5 | [Property] f: (val ... g } | semmle.label | [Property] f: (val ... g } | -| tst.ts:284:8:286:5 | [ArrowFunctionExpr] (val) = ... g } | semmle.label | [ArrowFunctionExpr] (val) = ... g } | -| tst.ts:284:9:284:11 | [SimpleParameter] val | semmle.label | [SimpleParameter] val | -| tst.ts:284:17:286:5 | [BlockStmt] { ... g } | semmle.label | [BlockStmt] { ... g } | -| tst.ts:285:7:285:13 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:285:7:285:17 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:285:7:285:36 | [MethodCallExpr] console ... Case()) | semmle.label | [MethodCallExpr] console ... Case()) | -| tst.ts:285:7:285:37 | [ExprStmt] console ... ase()); | semmle.label | [ExprStmt] console ... ase()); | -| tst.ts:285:15:285:17 | [Label] log | semmle.label | [Label] log | -| tst.ts:285:19:285:21 | [VarRef] val | semmle.label | [VarRef] val | -| tst.ts:285:19:285:33 | [DotExpr] val.toUpperCase | semmle.label | [DotExpr] val.toUpperCase | -| tst.ts:285:19:285:35 | [MethodCallExpr] val.toUpperCase() | semmle.label | [MethodCallExpr] val.toUpperCase() | -| tst.ts:285:23:285:33 | [Label] toUpperCase | semmle.label | [Label] toUpperCase | -| tst.ts:289:3:289:63 | [TypeAliasDeclaration,TypeDefinition] type Fu ... > void; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Fu ... > void; | -| tst.ts:289:8:289:11 | [Identifier] Func | semmle.label | [Identifier] Func | -| tst.ts:289:15:289:62 | [FunctionExpr] (...arg ... => void | semmle.label | [FunctionExpr] (...arg ... => void | -| tst.ts:289:15:289:62 | [FunctionTypeExpr] (...arg ... => void | semmle.label | [FunctionTypeExpr] (...arg ... => void | -| tst.ts:289:19:289:22 | [SimpleParameter] args | semmle.label | [SimpleParameter] args | -| tst.ts:289:25:289:37 | [TupleTypeExpr] ["a", number] | semmle.label | [TupleTypeExpr] ["a", number] | -| tst.ts:289:25:289:53 | [UnionTypeExpr] ["a", n ... string] | semmle.label | [UnionTypeExpr] ["a", n ... string] | -| tst.ts:289:26:289:28 | [LiteralTypeExpr] "a" | semmle.label | [LiteralTypeExpr] "a" | -| tst.ts:289:31:289:36 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:289:41:289:53 | [TupleTypeExpr] ["b", string] | semmle.label | [TupleTypeExpr] ["b", string] | -| tst.ts:289:42:289:44 | [LiteralTypeExpr] "b" | semmle.label | [LiteralTypeExpr] "b" | -| tst.ts:289:47:289:52 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:289:59:289:62 | [KeywordTypeExpr] void | semmle.label | [KeywordTypeExpr] void | -| tst.ts:291:3:295:4 | [DeclStmt] const f1 = ... | semmle.label | [DeclStmt] const f1 = ... | -| tst.ts:291:9:291:10 | [VarDecl] f1 | semmle.label | [VarDecl] f1 | -| tst.ts:291:9:295:3 | [VariableDeclarator] f1: Fun ... } } | semmle.label | [VariableDeclarator] f1: Fun ... } } | -| tst.ts:291:13:291:16 | [LocalTypeAccess] Func | semmle.label | [LocalTypeAccess] Func | -| tst.ts:291:20:295:3 | [ArrowFunctionExpr] (kind, ... } } | semmle.label | [ArrowFunctionExpr] (kind, ... } } | -| tst.ts:291:21:291:24 | [SimpleParameter] kind | semmle.label | [SimpleParameter] kind | -| tst.ts:291:27:291:33 | [SimpleParameter] payload | semmle.label | [SimpleParameter] payload | -| tst.ts:291:39:295:3 | [BlockStmt] { i ... } } | semmle.label | [BlockStmt] { i ... } } | -| tst.ts:292:5:294:5 | [IfStmt] if (kin ... r } | semmle.label | [IfStmt] if (kin ... r } | -| tst.ts:292:9:292:12 | [VarRef] kind | semmle.label | [VarRef] kind | -| tst.ts:292:9:292:20 | [BinaryExpr] kind === "a" | semmle.label | [BinaryExpr] kind === "a" | -| tst.ts:292:18:292:20 | [Literal] "a" | semmle.label | [Literal] "a" | -| tst.ts:292:23:294:5 | [BlockStmt] { ... r } | semmle.label | [BlockStmt] { ... r } | -| tst.ts:293:7:293:13 | [VarRef] payload | semmle.label | [VarRef] payload | -| tst.ts:293:7:293:21 | [DotExpr] payload.toFixed | semmle.label | [DotExpr] payload.toFixed | -| tst.ts:293:7:293:23 | [MethodCallExpr] payload.toFixed() | semmle.label | [MethodCallExpr] payload.toFixed() | -| tst.ts:293:7:293:24 | [ExprStmt] payload.toFixed(); | semmle.label | [ExprStmt] payload.toFixed(); | -| tst.ts:293:15:293:21 | [Label] toFixed | semmle.label | [Label] toFixed | -| tst.ts:298:1:298:21 | [DeclStmt] const key = ... | semmle.label | [DeclStmt] const key = ... | -| tst.ts:298:1:298:21 | [DeclStmt] const key = ... | semmle.order | 64 | -| tst.ts:298:7:298:9 | [VarDecl] key | semmle.label | [VarDecl] key | -| tst.ts:298:7:298:20 | [VariableDeclarator] key = Symbol() | semmle.label | [VariableDeclarator] key = Symbol() | -| tst.ts:298:13:298:18 | [VarRef] Symbol | semmle.label | [VarRef] Symbol | -| tst.ts:298:13:298:20 | [CallExpr] Symbol() | semmle.label | [CallExpr] Symbol() | -| tst.ts:300:1:300:58 | [DeclStmt] const numberOrString = ... | semmle.label | [DeclStmt] const numberOrString = ... | -| tst.ts:300:1:300:58 | [DeclStmt] const numberOrString = ... | semmle.order | 65 | -| tst.ts:300:7:300:20 | [VarDecl] numberOrString | semmle.label | [VarDecl] numberOrString | -| tst.ts:300:7:300:57 | [VariableDeclarator] numberO ... "hello" | semmle.label | [VariableDeclarator] numberO ... "hello" | -| tst.ts:300:24:300:27 | [VarRef] Math | semmle.label | [VarRef] Math | -| tst.ts:300:24:300:34 | [DotExpr] Math.random | semmle.label | [DotExpr] Math.random | -| tst.ts:300:24:300:36 | [MethodCallExpr] Math.random() | semmle.label | [MethodCallExpr] Math.random() | -| tst.ts:300:24:300:42 | [BinaryExpr] Math.random() < 0.5 | semmle.label | [BinaryExpr] Math.random() < 0.5 | -| tst.ts:300:24:300:57 | [ConditionalExpr] Math.ra ... "hello" | semmle.label | [ConditionalExpr] Math.ra ... "hello" | -| tst.ts:300:29:300:34 | [Label] random | semmle.label | [Label] random | -| tst.ts:300:40:300:42 | [Literal] 0.5 | semmle.label | [Literal] 0.5 | -| tst.ts:300:46:300:47 | [Literal] 42 | semmle.label | [Literal] 42 | -| tst.ts:300:51:300:57 | [Literal] "hello" | semmle.label | [Literal] "hello" | -| tst.ts:302:1:304:2 | [DeclStmt] let obj = ... | semmle.label | [DeclStmt] let obj = ... | -| tst.ts:302:1:304:2 | [DeclStmt] let obj = ... | semmle.order | 66 | -| tst.ts:302:5:302:7 | [VarDecl] obj | semmle.label | [VarDecl] obj | -| tst.ts:302:5:304:1 | [VariableDeclarator] obj = { ... ring, } | semmle.label | [VariableDeclarator] obj = { ... ring, } | -| tst.ts:302:11:304:1 | [ObjectExpr] { [ke ... ring, } | semmle.label | [ObjectExpr] { [ke ... ring, } | -| tst.ts:303:3:303:23 | [Property] [key]: ... rString | semmle.label | [Property] [key]: ... rString | -| tst.ts:303:4:303:6 | [VarRef] key | semmle.label | [VarRef] key | -| tst.ts:303:10:303:23 | [VarRef] numberOrString | semmle.label | [VarRef] numberOrString | -| tst.ts:306:1:309:1 | [IfStmt] if (typ ... se(); } | semmle.label | [IfStmt] if (typ ... se(); } | -| tst.ts:306:1:309:1 | [IfStmt] if (typ ... se(); } | semmle.order | 67 | -| tst.ts:306:5:306:19 | [UnaryExpr] typeof obj[key] | semmle.label | [UnaryExpr] typeof obj[key] | -| tst.ts:306:5:306:32 | [BinaryExpr] typeof ... string" | semmle.label | [BinaryExpr] typeof ... string" | -| tst.ts:306:12:306:14 | [VarRef] obj | semmle.label | [VarRef] obj | -| tst.ts:306:12:306:19 | [IndexExpr] obj[key] | semmle.label | [IndexExpr] obj[key] | -| tst.ts:306:16:306:18 | [VarRef] key | semmle.label | [VarRef] key | -| tst.ts:306:25:306:32 | [Literal] "string" | semmle.label | [Literal] "string" | -| tst.ts:306:35:309:1 | [BlockStmt] { let ... se(); } | semmle.label | [BlockStmt] { let ... se(); } | -| tst.ts:307:3:307:21 | [DeclStmt] let str = ... | semmle.label | [DeclStmt] let str = ... | -| tst.ts:307:7:307:9 | [VarDecl] str | semmle.label | [VarDecl] str | -| tst.ts:307:7:307:20 | [VariableDeclarator] str = obj[key] | semmle.label | [VariableDeclarator] str = obj[key] | -| tst.ts:307:13:307:15 | [VarRef] obj | semmle.label | [VarRef] obj | -| tst.ts:307:13:307:20 | [IndexExpr] obj[key] | semmle.label | [IndexExpr] obj[key] | -| tst.ts:307:17:307:19 | [VarRef] key | semmle.label | [VarRef] key | -| tst.ts:308:3:308:5 | [VarRef] str | semmle.label | [VarRef] str | -| tst.ts:308:3:308:17 | [DotExpr] str.toUpperCase | semmle.label | [DotExpr] str.toUpperCase | -| tst.ts:308:3:308:19 | [MethodCallExpr] str.toUpperCase() | semmle.label | [MethodCallExpr] str.toUpperCase() | -| tst.ts:308:3:308:20 | [ExprStmt] str.toUpperCase(); | semmle.label | [ExprStmt] str.toUpperCase(); | -| tst.ts:308:7:308:17 | [Label] toUpperCase | semmle.label | [Label] toUpperCase | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | semmle.label | [FunctionDeclStmt] functio ... void {} | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | semmle.order | 68 | -| tst.ts:313:10:313:10 | [VarDecl] f | semmle.label | [VarDecl] f | -| tst.ts:313:12:313:12 | [Identifier] T | semmle.label | [Identifier] T | -| tst.ts:313:12:313:12 | [TypeParameter] T | semmle.label | [TypeParameter] T | -| tst.ts:313:15:313:17 | [SimpleParameter] arg | semmle.label | [SimpleParameter] arg | -| tst.ts:313:20:315:27 | [InterfaceTypeExpr] { pro ... void } | semmle.label | [InterfaceTypeExpr] { pro ... void } | -| tst.ts:314:3:314:9 | [Label] produce | semmle.label | [Label] produce | -| tst.ts:314:3:314:28 | [FieldDeclaration] produce ... ) => T, | semmle.label | [FieldDeclaration] produce ... ) => T, | -| tst.ts:314:12:314:27 | [FunctionExpr] (n: string) => T | semmle.label | [FunctionExpr] (n: string) => T | -| tst.ts:314:12:314:27 | [FunctionTypeExpr] (n: string) => T | semmle.label | [FunctionTypeExpr] (n: string) => T | -| tst.ts:314:13:314:13 | [SimpleParameter] n | semmle.label | [SimpleParameter] n | -| tst.ts:314:16:314:21 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:314:27:314:27 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:315:3:315:9 | [Label] consume | semmle.label | [Label] consume | -| tst.ts:315:3:315:25 | [FieldDeclaration] consume ... => void | semmle.label | [FieldDeclaration] consume ... => void | -| tst.ts:315:12:315:25 | [FunctionExpr] (x: T) => void | semmle.label | [FunctionExpr] (x: T) => void | -| tst.ts:315:12:315:25 | [FunctionTypeExpr] (x: T) => void | semmle.label | [FunctionTypeExpr] (x: T) => void | -| tst.ts:315:13:315:13 | [SimpleParameter] x | semmle.label | [SimpleParameter] x | -| tst.ts:315:16:315:16 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:315:22:315:25 | [KeywordTypeExpr] void | semmle.label | [KeywordTypeExpr] void | -| tst.ts:316:4:316:7 | [KeywordTypeExpr] void | semmle.label | [KeywordTypeExpr] void | -| tst.ts:316:9:316:10 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:316:11:316:11 | [EmptyStmt] ; | semmle.label | [EmptyStmt] ; | -| tst.ts:316:11:316:11 | [EmptyStmt] ; | semmle.order | 69 | -| tst.ts:318:1:318:1 | [VarRef] f | semmle.label | [VarRef] f | -| tst.ts:318:1:321:2 | [CallExpr] f({ p ... se() }) | semmle.label | [CallExpr] f({ p ... se() }) | -| tst.ts:318:1:321:3 | [ExprStmt] f({ p ... e() }); | semmle.label | [ExprStmt] f({ p ... e() }); | -| tst.ts:318:1:321:3 | [ExprStmt] f({ p ... e() }); | semmle.order | 70 | -| tst.ts:318:3:321:1 | [ObjectExpr] {produce: ...} | semmle.label | [ObjectExpr] {produce: ...} | -| tst.ts:319:3:319:9 | [Label] produce | semmle.label | [Label] produce | -| tst.ts:319:3:319:17 | [Property] produce: n => n | semmle.label | [Property] produce: n => n | -| tst.ts:319:12:319:12 | [SimpleParameter] n | semmle.label | [SimpleParameter] n | -| tst.ts:319:12:319:17 | [ArrowFunctionExpr] n => n | semmle.label | [ArrowFunctionExpr] n => n | -| tst.ts:319:17:319:17 | [VarRef] n | semmle.label | [VarRef] n | -| tst.ts:320:3:320:9 | [Label] consume | semmle.label | [Label] consume | -| tst.ts:320:3:320:31 | [Property] consume ... rCase() | semmle.label | [Property] consume ... rCase() | -| tst.ts:320:12:320:12 | [SimpleParameter] x | semmle.label | [SimpleParameter] x | -| tst.ts:320:12:320:31 | [ArrowFunctionExpr] x => x.toLowerCase() | semmle.label | [ArrowFunctionExpr] x => x.toLowerCase() | -| tst.ts:320:17:320:17 | [VarRef] x | semmle.label | [VarRef] x | -| tst.ts:320:17:320:29 | [DotExpr] x.toLowerCase | semmle.label | [DotExpr] x.toLowerCase | -| tst.ts:320:17:320:31 | [MethodCallExpr] x.toLowerCase() | semmle.label | [MethodCallExpr] x.toLowerCase() | -| tst.ts:320:19:320:29 | [Label] toLowerCase | semmle.label | [Label] toLowerCase | -| tst.ts:325:1:325:36 | [DeclStmt] const ErrorMap = ... | semmle.label | [DeclStmt] const ErrorMap = ... | -| tst.ts:325:1:325:36 | [DeclStmt] const ErrorMap = ... | semmle.order | 71 | -| tst.ts:325:7:325:14 | [VarDecl] ErrorMap | semmle.label | [VarDecl] ErrorMap | -| tst.ts:325:7:325:35 | [VariableDeclarator] ErrorMa ... Error> | semmle.label | [VariableDeclarator] ErrorMa ... Error> | -| tst.ts:325:18:325:20 | [VarRef] Map | semmle.label | [VarRef] Map | -| tst.ts:325:18:325:35 | [ExpressionWithTypeArguments] Map | semmle.label | [ExpressionWithTypeArguments] Map | -| tst.ts:325:22:325:27 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:325:30:325:34 | [LocalTypeAccess] Error | semmle.label | [LocalTypeAccess] Error | -| tst.ts:327:1:327:32 | [DeclStmt] const errorMap = ... | semmle.label | [DeclStmt] const errorMap = ... | -| tst.ts:327:1:327:32 | [DeclStmt] const errorMap = ... | semmle.order | 72 | -| tst.ts:327:7:327:14 | [VarDecl] errorMap | semmle.label | [VarDecl] errorMap | -| tst.ts:327:7:327:31 | [VariableDeclarator] errorMa ... orMap() | semmle.label | [VariableDeclarator] errorMa ... orMap() | -| tst.ts:327:18:327:31 | [NewExpr] new ErrorMap() | semmle.label | [NewExpr] new ErrorMap() | -| tst.ts:327:22:327:29 | [VarRef] ErrorMap | semmle.label | [VarRef] ErrorMap | -| tst.ts:331:1:334:14 | [TypeAliasDeclaration,TypeDefinition] type Fi ... never; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Fi ... never; | -| tst.ts:331:1:334:14 | [TypeAliasDeclaration,TypeDefinition] type Fi ... never; | semmle.order | 73 | -| tst.ts:331:6:331:16 | [Identifier] FirstString | semmle.label | [Identifier] FirstString | -| tst.ts:331:18:331:18 | [Identifier] T | semmle.label | [Identifier] T | -| tst.ts:331:18:331:18 | [TypeParameter] T | semmle.label | [TypeParameter] T | -| tst.ts:332:3:332:3 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | semmle.label | [ConditionalTypeExpr] T exten ... : never | -| tst.ts:332:13:332:50 | [TupleTypeExpr] [infer ... nown[]] | semmle.label | [TupleTypeExpr] [infer ... nown[]] | -| tst.ts:332:14:332:35 | [InferTypeExpr] infer S ... string | semmle.label | [InferTypeExpr] infer S ... string | -| tst.ts:332:20:332:20 | [Identifier] S | semmle.label | [Identifier] S | -| tst.ts:332:20:332:35 | [TypeParameter] S extends string | semmle.label | [TypeParameter] S extends string | -| tst.ts:332:30:332:35 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:332:38:332:49 | [RestTypeExpr] ...unknown[] | semmle.label | [RestTypeExpr] ...unknown[] | -| tst.ts:332:41:332:47 | [KeywordTypeExpr] unknown | semmle.label | [KeywordTypeExpr] unknown | -| tst.ts:332:41:332:49 | [ArrayTypeExpr] unknown[] | semmle.label | [ArrayTypeExpr] unknown[] | -| tst.ts:333:9:333:9 | [LocalTypeAccess] S | semmle.label | [LocalTypeAccess] S | -| tst.ts:334:9:334:13 | [KeywordTypeExpr] never | semmle.label | [KeywordTypeExpr] never | -| tst.ts:336:1:336:51 | [TypeAliasDeclaration,TypeDefinition] type F ... lean]>; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type F ... lean]>; | -| tst.ts:336:1:336:51 | [TypeAliasDeclaration,TypeDefinition] type F ... lean]>; | semmle.order | 74 | -| tst.ts:336:6:336:6 | [Identifier] F | semmle.label | [Identifier] F | -| tst.ts:336:10:336:20 | [LocalTypeAccess] FirstString | semmle.label | [LocalTypeAccess] FirstString | -| tst.ts:336:10:336:50 | [GenericTypeExpr] FirstSt ... olean]> | semmle.label | [GenericTypeExpr] FirstSt ... olean]> | -| tst.ts:336:22:336:49 | [TupleTypeExpr] ['a' \| ... oolean] | semmle.label | [TupleTypeExpr] ['a' \| ... oolean] | -| tst.ts:336:23:336:25 | [LiteralTypeExpr] 'a' | semmle.label | [LiteralTypeExpr] 'a' | -| tst.ts:336:23:336:31 | [UnionTypeExpr] 'a' \| 'b' | semmle.label | [UnionTypeExpr] 'a' \| 'b' | -| tst.ts:336:29:336:31 | [LiteralTypeExpr] 'b' | semmle.label | [LiteralTypeExpr] 'b' | -| tst.ts:336:34:336:39 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:336:42:336:48 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| tst.ts:338:1:338:17 | [DeclStmt] const a = ... | semmle.label | [DeclStmt] const a = ... | -| tst.ts:338:1:338:17 | [DeclStmt] const a = ... | semmle.order | 75 | -| tst.ts:338:7:338:7 | [VarDecl] a | semmle.label | [VarDecl] a | -| tst.ts:338:7:338:16 | [VariableDeclarator] a: F = 'a' | semmle.label | [VariableDeclarator] a: F = 'a' | -| tst.ts:338:10:338:10 | [LocalTypeAccess] F | semmle.label | [LocalTypeAccess] F | -| tst.ts:338:14:338:16 | [Literal] 'a' | semmle.label | [Literal] 'a' | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | semmle.order | 76 | -| tst.ts:342:11:342:15 | [Identifier] State | semmle.label | [Identifier] State | -| tst.ts:342:17:342:24 | [TypeParameter] in out T | semmle.label | [TypeParameter] in out T | -| tst.ts:342:24:342:24 | [Identifier] T | semmle.label | [Identifier] T | -| tst.ts:343:3:343:5 | [Label] get | semmle.label | [Label] get | -| tst.ts:343:3:343:15 | [FieldDeclaration] get: () => T; | semmle.label | [FieldDeclaration] get: () => T; | -| tst.ts:343:8:343:14 | [FunctionExpr] () => T | semmle.label | [FunctionExpr] () => T | -| tst.ts:343:8:343:14 | [FunctionTypeExpr] () => T | semmle.label | [FunctionTypeExpr] () => T | -| tst.ts:343:14:343:14 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:344:3:344:5 | [Label] set | semmle.label | [Label] set | -| tst.ts:344:3:344:26 | [FieldDeclaration] set: (v ... > void; | semmle.label | [FieldDeclaration] set: (v ... > void; | -| tst.ts:344:8:344:25 | [FunctionExpr] (value: T) => void | semmle.label | [FunctionExpr] (value: T) => void | -| tst.ts:344:8:344:25 | [FunctionTypeExpr] (value: T) => void | semmle.label | [FunctionTypeExpr] (value: T) => void | -| tst.ts:344:9:344:13 | [SimpleParameter] value | semmle.label | [SimpleParameter] value | -| tst.ts:344:16:344:16 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:344:22:344:25 | [KeywordTypeExpr] void | semmle.label | [KeywordTypeExpr] void | -| tst.ts:347:1:350:1 | [DeclStmt] const state = ... | semmle.label | [DeclStmt] const state = ... | -| tst.ts:347:1:350:1 | [DeclStmt] const state = ... | semmle.order | 77 | -| tst.ts:347:7:347:11 | [VarDecl] state | semmle.label | [VarDecl] state | -| tst.ts:347:7:350:1 | [VariableDeclarator] state: ... > { } } | semmle.label | [VariableDeclarator] state: ... > { } } | -| tst.ts:347:14:347:18 | [LocalTypeAccess] State | semmle.label | [LocalTypeAccess] State | -| tst.ts:347:14:347:26 | [GenericTypeExpr] State | semmle.label | [GenericTypeExpr] State | -| tst.ts:347:20:347:25 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:347:30:350:1 | [ObjectExpr] {get: ...} | semmle.label | [ObjectExpr] {get: ...} | -| tst.ts:348:3:348:5 | [Label] get | semmle.label | [Label] get | -| tst.ts:348:3:348:15 | [Property] get: () => 42 | semmle.label | [Property] get: () => 42 | -| tst.ts:348:8:348:15 | [ArrowFunctionExpr] () => 42 | semmle.label | [ArrowFunctionExpr] () => 42 | -| tst.ts:348:14:348:15 | [Literal] 42 | semmle.label | [Literal] 42 | -| tst.ts:349:3:349:5 | [Label] set | semmle.label | [Label] set | -| tst.ts:349:3:349:21 | [Property] set: (value) => { } | semmle.label | [Property] set: (value) => { } | -| tst.ts:349:8:349:21 | [ArrowFunctionExpr] (value) => { } | semmle.label | [ArrowFunctionExpr] (value) => { } | -| tst.ts:349:9:349:13 | [SimpleParameter] value | semmle.label | [SimpleParameter] value | -| tst.ts:349:19:349:21 | [BlockStmt] { } | semmle.label | [BlockStmt] { } | -| tst.ts:352:1:352:29 | [DeclStmt] const fortyTwo = ... | semmle.label | [DeclStmt] const fortyTwo = ... | -| tst.ts:352:1:352:29 | [DeclStmt] const fortyTwo = ... | semmle.order | 78 | -| tst.ts:352:7:352:14 | [VarDecl] fortyTwo | semmle.label | [VarDecl] fortyTwo | -| tst.ts:352:7:352:28 | [VariableDeclarator] fortyTw ... e.get() | semmle.label | [VariableDeclarator] fortyTw ... e.get() | -| tst.ts:352:18:352:22 | [VarRef] state | semmle.label | [VarRef] state | -| tst.ts:352:18:352:26 | [DotExpr] state.get | semmle.label | [DotExpr] state.get | -| tst.ts:352:18:352:28 | [MethodCallExpr] state.get() | semmle.label | [MethodCallExpr] state.get() | -| tst.ts:352:24:352:26 | [Label] get | semmle.label | [Label] get | -| tst.ts:356:1:356:44 | [ImportDeclaration] import ... S.mjs'; | semmle.label | [ImportDeclaration] import ... S.mjs'; | -| tst.ts:356:1:356:44 | [ImportDeclaration] import ... S.mjs'; | semmle.order | 79 | -| tst.ts:356:8:356:18 | [ImportSpecifier] tstModuleES | semmle.label | [ImportSpecifier] tstModuleES | -| tst.ts:356:8:356:18 | [VarDecl] tstModuleES | semmle.label | [VarDecl] tstModuleES | -| tst.ts:356:25:356:43 | [Literal] './tstModuleES.mjs' | semmle.label | [Literal] './tstModuleES.mjs' | -| tst.ts:358:1:358:7 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:358:1:358:11 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:358:1:358:26 | [MethodCallExpr] console ... leES()) | semmle.label | [MethodCallExpr] console ... leES()) | -| tst.ts:358:1:358:27 | [ExprStmt] console ... eES()); | semmle.label | [ExprStmt] console ... eES()); | -| tst.ts:358:1:358:27 | [ExprStmt] console ... eES()); | semmle.order | 80 | -| tst.ts:358:9:358:11 | [Label] log | semmle.label | [Label] log | -| tst.ts:358:13:358:23 | [VarRef] tstModuleES | semmle.label | [VarRef] tstModuleES | -| tst.ts:358:13:358:25 | [CallExpr] tstModuleES() | semmle.label | [CallExpr] tstModuleES() | -| tst.ts:360:1:360:50 | [ImportDeclaration] import ... S.cjs'; | semmle.label | [ImportDeclaration] import ... S.cjs'; | -| tst.ts:360:1:360:50 | [ImportDeclaration] import ... S.cjs'; | semmle.order | 81 | -| tst.ts:360:10:360:21 | [ImportSpecifier] tstModuleCJS | semmle.label | [ImportSpecifier] tstModuleCJS | -| tst.ts:360:10:360:21 | [Label] tstModuleCJS | semmle.label | [Label] tstModuleCJS | -| tst.ts:360:10:360:21 | [VarDecl] tstModuleCJS | semmle.label | [VarDecl] tstModuleCJS | -| tst.ts:360:30:360:49 | [Literal] './tstModuleCJS.cjs' | semmle.label | [Literal] './tstModuleCJS.cjs' | -| tst.ts:362:1:362:7 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:362:1:362:11 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:362:1:362:27 | [MethodCallExpr] console ... eCJS()) | semmle.label | [MethodCallExpr] console ... eCJS()) | -| tst.ts:362:1:362:28 | [ExprStmt] console ... CJS()); | semmle.label | [ExprStmt] console ... CJS()); | -| tst.ts:362:1:362:28 | [ExprStmt] console ... CJS()); | semmle.order | 82 | -| tst.ts:362:9:362:11 | [Label] log | semmle.label | [Label] log | -| tst.ts:362:13:362:24 | [VarRef] tstModuleCJS | semmle.label | [VarRef] tstModuleCJS | -| tst.ts:362:13:362:26 | [CallExpr] tstModuleCJS() | semmle.label | [CallExpr] tstModuleCJS() | -| tst.ts:368:1:368:34 | [ImportDeclaration] import ... ffixA'; | semmle.label | [ImportDeclaration] import ... ffixA'; | -| tst.ts:368:1:368:34 | [ImportDeclaration] import ... ffixA'; | semmle.order | 83 | -| tst.ts:368:8:368:13 | [ImportSpecifier] * as A | semmle.label | [ImportSpecifier] * as A | -| tst.ts:368:13:368:13 | [VarDecl] A | semmle.label | [VarDecl] A | -| tst.ts:368:20:368:33 | [Literal] './tstSuffixA' | semmle.label | [Literal] './tstSuffixA' | -| tst.ts:370:1:370:7 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:370:1:370:11 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:370:1:370:29 | [MethodCallExpr] console ... File()) | semmle.label | [MethodCallExpr] console ... File()) | -| tst.ts:370:1:370:30 | [ExprStmt] console ... ile()); | semmle.label | [ExprStmt] console ... ile()); | -| tst.ts:370:1:370:30 | [ExprStmt] console ... ile()); | semmle.order | 84 | -| tst.ts:370:9:370:11 | [Label] log | semmle.label | [Label] log | -| tst.ts:370:13:370:13 | [VarRef] A | semmle.label | [VarRef] A | -| tst.ts:370:13:370:26 | [DotExpr] A.resolvedFile | semmle.label | [DotExpr] A.resolvedFile | -| tst.ts:370:13:370:28 | [MethodCallExpr] A.resolvedFile() | semmle.label | [MethodCallExpr] A.resolvedFile() | -| tst.ts:370:15:370:26 | [Label] resolvedFile | semmle.label | [Label] resolvedFile | -| tst.ts:372:1:372:34 | [ImportDeclaration] import ... ffixB'; | semmle.label | [ImportDeclaration] import ... ffixB'; | -| tst.ts:372:1:372:34 | [ImportDeclaration] import ... ffixB'; | semmle.order | 85 | -| tst.ts:372:8:372:13 | [ImportSpecifier] * as B | semmle.label | [ImportSpecifier] * as B | -| tst.ts:372:13:372:13 | [VarDecl] B | semmle.label | [VarDecl] B | -| tst.ts:372:20:372:33 | [Literal] './tstSuffixB' | semmle.label | [Literal] './tstSuffixB' | -| tst.ts:374:1:374:7 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:374:1:374:11 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:374:1:374:29 | [MethodCallExpr] console ... File()) | semmle.label | [MethodCallExpr] console ... File()) | -| tst.ts:374:1:374:30 | [ExprStmt] console ... ile()); | semmle.label | [ExprStmt] console ... ile()); | -| tst.ts:374:1:374:30 | [ExprStmt] console ... ile()); | semmle.order | 86 | -| tst.ts:374:9:374:11 | [Label] log | semmle.label | [Label] log | -| tst.ts:374:13:374:13 | [VarRef] B | semmle.label | [VarRef] B | -| tst.ts:374:13:374:26 | [DotExpr] B.resolvedFile | semmle.label | [DotExpr] B.resolvedFile | -| tst.ts:374:13:374:28 | [MethodCallExpr] B.resolvedFile() | semmle.label | [MethodCallExpr] B.resolvedFile() | -| tst.ts:374:15:374:26 | [Label] resolvedFile | semmle.label | [Label] resolvedFile | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | semmle.label | [NamespaceDeclaration] module ... ; } | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | semmle.order | 87 | -| tst.ts:379:8:379:11 | [VarDecl] TS48 | semmle.label | [VarDecl] TS48 | -| tst.ts:381:5:381:73 | [TypeAliasDeclaration,TypeDefinition] type So ... never; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type So ... never; | -| tst.ts:381:10:381:16 | [Identifier] SomeNum | semmle.label | [Identifier] SomeNum | -| tst.ts:381:20:381:24 | [LiteralTypeExpr] "100" | semmle.label | [LiteralTypeExpr] "100" | -| tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | semmle.label | [ConditionalTypeExpr] "100" e ... : never | -| tst.ts:381:34:381:60 | [TemplateLiteralTypeExpr] `${infe ... umber}` | semmle.label | [TemplateLiteralTypeExpr] `${infe ... umber}` | -| tst.ts:381:37:381:58 | [InferTypeExpr] infer U ... number | semmle.label | [InferTypeExpr] infer U ... number | -| tst.ts:381:43:381:43 | [Identifier] U | semmle.label | [Identifier] U | -| tst.ts:381:43:381:58 | [TypeParameter] U extends number | semmle.label | [TypeParameter] U extends number | -| tst.ts:381:53:381:58 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:381:64:381:64 | [LocalTypeAccess] U | semmle.label | [LocalTypeAccess] U | -| tst.ts:381:68:381:72 | [KeywordTypeExpr] never | semmle.label | [KeywordTypeExpr] never | -| tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | semmle.label | [FunctionDeclStmt] declare ... T): T; | -| tst.ts:383:22:383:35 | [VarDecl] chooseRandomly | semmle.label | [VarDecl] chooseRandomly | -| tst.ts:383:37:383:37 | [Identifier] T | semmle.label | [Identifier] T | -| tst.ts:383:37:383:37 | [TypeParameter] T | semmle.label | [TypeParameter] T | -| tst.ts:383:40:383:40 | [SimpleParameter] x | semmle.label | [SimpleParameter] x | -| tst.ts:383:43:383:43 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:383:46:383:46 | [SimpleParameter] y | semmle.label | [SimpleParameter] y | -| tst.ts:383:49:383:49 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:383:53:383:53 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:385:5:385:74 | [DeclStmt] let [a, ... ye!"]); | semmle.label | [DeclStmt] let [a, ... ye!"]); | -| tst.ts:385:9:385:17 | [ArrayPattern] [a, b, c] | semmle.label | [ArrayPattern] [a, b, c] | -| tst.ts:385:9:385:73 | [VariableDeclarator] [a, b, ... bye!"]) | semmle.label | [VariableDeclarator] [a, b, ... bye!"]) | -| tst.ts:385:10:385:10 | [VarDecl] a | semmle.label | [VarDecl] a | -| tst.ts:385:13:385:13 | [VarDecl] b | semmle.label | [VarDecl] b | -| tst.ts:385:16:385:16 | [VarDecl] c | semmle.label | [VarDecl] c | -| tst.ts:385:21:385:34 | [VarRef] chooseRandomly | semmle.label | [VarRef] chooseRandomly | -| tst.ts:385:21:385:73 | [CallExpr] chooseR ... bye!"]) | semmle.label | [CallExpr] chooseR ... bye!"]) | -| tst.ts:385:36:385:52 | [ArrayExpr] [42, true, "hi!"] | semmle.label | [ArrayExpr] [42, true, "hi!"] | -| tst.ts:385:37:385:38 | [Literal] 42 | semmle.label | [Literal] 42 | -| tst.ts:385:41:385:44 | [Literal] true | semmle.label | [Literal] true | -| tst.ts:385:47:385:51 | [Literal] "hi!" | semmle.label | [Literal] "hi!" | -| tst.ts:385:55:385:72 | [ArrayExpr] [0, false, "bye!"] | semmle.label | [ArrayExpr] [0, false, "bye!"] | -| tst.ts:385:56:385:56 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:385:59:385:63 | [Literal] false | semmle.label | [Literal] false | -| tst.ts:385:66:385:71 | [Literal] "bye!" | semmle.label | [Literal] "bye!" | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | semmle.label | [NamespaceDeclaration] module ... } } } | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | semmle.order | 88 | -| tst.ts:390:8:390:11 | [VarDecl] TS49 | semmle.label | [VarDecl] TS49 | -| tst.ts:391:3:391:41 | [TypeAliasDeclaration,TypeDefinition] type Co ... "blue"; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Co ... "blue"; | -| tst.ts:391:8:391:13 | [Identifier] Colors | semmle.label | [Identifier] Colors | -| tst.ts:391:17:391:21 | [LiteralTypeExpr] "red" | semmle.label | [LiteralTypeExpr] "red" | -| tst.ts:391:17:391:40 | [UnionTypeExpr] "red" \| ... "blue" | semmle.label | [UnionTypeExpr] "red" \| ... "blue" | -| tst.ts:391:25:391:31 | [LiteralTypeExpr] "green" | semmle.label | [LiteralTypeExpr] "green" | -| tst.ts:391:35:391:40 | [LiteralTypeExpr] "blue" | semmle.label | [LiteralTypeExpr] "blue" | -| tst.ts:393:3:393:56 | [TypeAliasDeclaration,TypeDefinition] type RG ... umber]; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type RG ... umber]; | -| tst.ts:393:8:393:10 | [Identifier] RGB | semmle.label | [Identifier] RGB | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | semmle.label | [TupleTypeExpr] [red: n ... number] | -| tst.ts:393:15:393:17 | [Identifier] red | semmle.label | [Identifier] red | -| tst.ts:393:20:393:25 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:393:28:393:32 | [Identifier] green | semmle.label | [Identifier] green | -| tst.ts:393:35:393:40 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:393:43:393:46 | [Identifier] blue | semmle.label | [Identifier] blue | -| tst.ts:393:49:393:54 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:395:3:399:43 | [DeclStmt] const palette = ... | semmle.label | [DeclStmt] const palette = ... | -| tst.ts:395:9:395:15 | [VarDecl] palette | semmle.label | [VarDecl] palette | -| tst.ts:395:9:399:42 | [VariableDeclarator] palette ... \| RGB> | semmle.label | [VariableDeclarator] palette ... \| RGB> | -| tst.ts:395:19:399:3 | [ObjectExpr] {red: ...} | semmle.label | [ObjectExpr] {red: ...} | -| tst.ts:395:19:399:42 | [SatisfiesExpr] { r ... \| RGB> | semmle.label | [SatisfiesExpr] { r ... \| RGB> | -| tst.ts:396:5:396:7 | [Label] red | semmle.label | [Label] red | -| tst.ts:396:5:396:20 | [Property] red: [255, 0, 0] | semmle.label | [Property] red: [255, 0, 0] | -| tst.ts:396:10:396:20 | [ArrayExpr] [255, 0, 0] | semmle.label | [ArrayExpr] [255, 0, 0] | -| tst.ts:396:11:396:13 | [Literal] 255 | semmle.label | [Literal] 255 | -| tst.ts:396:16:396:16 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:396:19:396:19 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:397:5:397:9 | [Label] green | semmle.label | [Label] green | -| tst.ts:397:5:397:20 | [Property] green: "#00ff00" | semmle.label | [Property] green: "#00ff00" | -| tst.ts:397:12:397:20 | [Literal] "#00ff00" | semmle.label | [Literal] "#00ff00" | -| tst.ts:398:5:398:8 | [Label] bleu | semmle.label | [Label] bleu | -| tst.ts:398:5:398:21 | [Property] bleu: [0, 0, 255] | semmle.label | [Property] bleu: [0, 0, 255] | -| tst.ts:398:11:398:21 | [ArrayExpr] [0, 0, 255] | semmle.label | [ArrayExpr] [0, 0, 255] | -| tst.ts:398:12:398:12 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:398:15:398:15 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:398:18:398:20 | [Literal] 255 | semmle.label | [Literal] 255 | -| tst.ts:399:15:399:20 | [LocalTypeAccess] Record | semmle.label | [LocalTypeAccess] Record | -| tst.ts:399:15:399:42 | [GenericTypeExpr] Record< ... \| RGB> | semmle.label | [GenericTypeExpr] Record< ... \| RGB> | -| tst.ts:399:22:399:27 | [LocalTypeAccess] Colors | semmle.label | [LocalTypeAccess] Colors | -| tst.ts:399:30:399:35 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:399:30:399:41 | [UnionTypeExpr] string \| RGB | semmle.label | [UnionTypeExpr] string \| RGB | -| tst.ts:399:39:399:41 | [LocalTypeAccess] RGB | semmle.label | [LocalTypeAccess] RGB | -| tst.ts:402:3:402:41 | [DeclStmt] const redComponent = ... | semmle.label | [DeclStmt] const redComponent = ... | -| tst.ts:402:9:402:20 | [VarDecl] redComponent | semmle.label | [VarDecl] redComponent | -| tst.ts:402:9:402:40 | [VariableDeclarator] redComp ... d.at(0) | semmle.label | [VariableDeclarator] redComp ... d.at(0) | -| tst.ts:402:24:402:30 | [VarRef] palette | semmle.label | [VarRef] palette | -| tst.ts:402:24:402:34 | [DotExpr] palette.red | semmle.label | [DotExpr] palette.red | -| tst.ts:402:24:402:37 | [DotExpr] palette.red.at | semmle.label | [DotExpr] palette.red.at | -| tst.ts:402:24:402:40 | [MethodCallExpr] palette.red.at(0) | semmle.label | [MethodCallExpr] palette.red.at(0) | -| tst.ts:402:32:402:34 | [Label] red | semmle.label | [Label] red | -| tst.ts:402:36:402:37 | [Label] at | semmle.label | [Label] at | -| tst.ts:402:39:402:39 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:404:3:406:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | -| tst.ts:404:13:404:18 | [Identifier] RGBObj | semmle.label | [Identifier] RGBObj | -| tst.ts:405:5:405:7 | [Label] red | semmle.label | [Label] red | -| tst.ts:405:5:405:16 | [FieldDeclaration] red: number; | semmle.label | [FieldDeclaration] red: number; | -| tst.ts:405:10:405:15 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:408:3:410:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | -| tst.ts:408:13:408:18 | [Identifier] HSVObj | semmle.label | [Identifier] HSVObj | -| tst.ts:409:5:409:7 | [Label] hue | semmle.label | [Label] hue | -| tst.ts:409:5:409:16 | [FieldDeclaration] hue: number; | semmle.label | [FieldDeclaration] hue: number; | -| tst.ts:409:10:409:15 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| tst.ts:412:3:416:3 | [FunctionDeclStmt] functio ... } } | semmle.label | [FunctionDeclStmt] functio ... } } | -| tst.ts:412:12:412:19 | [VarDecl] setColor | semmle.label | [VarDecl] setColor | -| tst.ts:412:21:412:25 | [SimpleParameter] color | semmle.label | [SimpleParameter] color | -| tst.ts:412:28:412:33 | [LocalTypeAccess] RGBObj | semmle.label | [LocalTypeAccess] RGBObj | -| tst.ts:412:28:412:42 | [UnionTypeExpr] RGBObj \| HSVObj | semmle.label | [UnionTypeExpr] RGBObj \| HSVObj | -| tst.ts:412:37:412:42 | [LocalTypeAccess] HSVObj | semmle.label | [LocalTypeAccess] HSVObj | -| tst.ts:412:45:416:3 | [BlockStmt] { i ... } } | semmle.label | [BlockStmt] { i ... } } | -| tst.ts:413:5:415:5 | [IfStmt] if ("hu ... j } | semmle.label | [IfStmt] if ("hu ... j } | -| tst.ts:413:9:413:13 | [Literal] "hue" | semmle.label | [Literal] "hue" | -| tst.ts:413:9:413:22 | [BinaryExpr] "hue" in color | semmle.label | [BinaryExpr] "hue" in color | -| tst.ts:413:18:413:22 | [VarRef] color | semmle.label | [VarRef] color | -| tst.ts:413:25:415:5 | [BlockStmt] { ... j } | semmle.label | [BlockStmt] { ... j } | -| tst.ts:414:7:414:20 | [DeclStmt] let h = ... | semmle.label | [DeclStmt] let h = ... | -| tst.ts:414:11:414:11 | [VarDecl] h | semmle.label | [VarDecl] h | -| tst.ts:414:11:414:19 | [VariableDeclarator] h = color | semmle.label | [VariableDeclarator] h = color | -| tst.ts:414:15:414:19 | [VarRef] color | semmle.label | [VarRef] color | -| tst.ts:419:3:425:3 | [ClassDefinition,TypeDefinition] class P ... } } | semmle.label | [ClassDefinition,TypeDefinition] class P ... } } | -| tst.ts:419:9:419:14 | [VarDecl] Person | semmle.label | [VarDecl] Person | -| tst.ts:420:5:420:26 | [FieldDeclaration] accesso ... string; | semmle.label | [FieldDeclaration] accesso ... string; | -| tst.ts:420:14:420:17 | [Label] name | semmle.label | [Label] name | -| tst.ts:420:20:420:25 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:422:5:424:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | semmle.label | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | -| tst.ts:422:5:424:5 | [FunctionExpr] constru ... ; } | semmle.label | [FunctionExpr] constru ... ; } | -| tst.ts:422:5:424:5 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:422:17:422:20 | [SimpleParameter] name | semmle.label | [SimpleParameter] name | -| tst.ts:422:23:422:28 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:422:31:424:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:423:7:423:10 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:423:7:423:15 | [DotExpr] this.name | semmle.label | [DotExpr] this.name | -| tst.ts:423:7:423:22 | [AssignExpr] this.name = name | semmle.label | [AssignExpr] this.name = name | -| tst.ts:423:7:423:23 | [ExprStmt] this.name = name; | semmle.label | [ExprStmt] this.name = name; | -| tst.ts:423:12:423:15 | [Label] name | semmle.label | [Label] name | -| tst.ts:423:19:423:22 | [VarRef] name | semmle.label | [VarRef] name | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | semmle.label | [NamespaceDeclaration] module ... - "b" } | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | semmle.order | 89 | -| tst.ts:430:8:430:11 | [VarDecl] TS50 | semmle.label | [VarDecl] TS50 | -| tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | semmle.label | [FunctionDeclStmt] functio ... ; } | -| tst.ts:431:14:431:25 | [VarDecl] loggedMethod | semmle.label | [VarDecl] loggedMethod | -| tst.ts:431:27:431:30 | [Identifier] This | semmle.label | [Identifier] This | -| tst.ts:431:27:431:30 | [TypeParameter] This | semmle.label | [TypeParameter] This | -| tst.ts:431:33:431:36 | [Identifier] Args | semmle.label | [Identifier] Args | -| tst.ts:431:33:431:50 | [TypeParameter] Args extends any[] | semmle.label | [TypeParameter] Args extends any[] | -| tst.ts:431:46:431:48 | [KeywordTypeExpr] any | semmle.label | [KeywordTypeExpr] any | -| tst.ts:431:46:431:50 | [ArrayTypeExpr] any[] | semmle.label | [ArrayTypeExpr] any[] | -| tst.ts:431:53:431:58 | [Identifier] Return | semmle.label | [Identifier] Return | -| tst.ts:431:53:431:58 | [TypeParameter] Return | semmle.label | [TypeParameter] Return | -| tst.ts:432:9:432:14 | [SimpleParameter] target | semmle.label | [SimpleParameter] target | -| tst.ts:432:17:432:53 | [FunctionExpr] (this: ... Return | semmle.label | [FunctionExpr] (this: ... Return | -| tst.ts:432:17:432:53 | [FunctionTypeExpr] (this: ... Return | semmle.label | [FunctionTypeExpr] (this: ... Return | -| tst.ts:432:24:432:27 | [LocalTypeAccess] This | semmle.label | [LocalTypeAccess] This | -| tst.ts:432:33:432:36 | [SimpleParameter] args | semmle.label | [SimpleParameter] args | -| tst.ts:432:39:432:42 | [LocalTypeAccess] Args | semmle.label | [LocalTypeAccess] Args | -| tst.ts:432:48:432:53 | [LocalTypeAccess] Return | semmle.label | [LocalTypeAccess] Return | -| tst.ts:433:9:433:15 | [SimpleParameter] context | semmle.label | [SimpleParameter] context | -| tst.ts:433:18:433:44 | [LocalTypeAccess] ClassMethodDecoratorContext | semmle.label | [LocalTypeAccess] ClassMethodDecoratorContext | -| tst.ts:433:18:433:89 | [GenericTypeExpr] ClassMe ... Return> | semmle.label | [GenericTypeExpr] ClassMe ... Return> | -| tst.ts:433:46:433:49 | [LocalTypeAccess] This | semmle.label | [LocalTypeAccess] This | -| tst.ts:433:52:433:88 | [FunctionExpr] (this: ... Return | semmle.label | [FunctionExpr] (this: ... Return | -| tst.ts:433:52:433:88 | [FunctionTypeExpr] (this: ... Return | semmle.label | [FunctionTypeExpr] (this: ... Return | -| tst.ts:433:59:433:62 | [LocalTypeAccess] This | semmle.label | [LocalTypeAccess] This | -| tst.ts:433:68:433:71 | [SimpleParameter] args | semmle.label | [SimpleParameter] args | -| tst.ts:433:74:433:77 | [LocalTypeAccess] Args | semmle.label | [LocalTypeAccess] Args | -| tst.ts:433:83:433:88 | [LocalTypeAccess] Return | semmle.label | [LocalTypeAccess] Return | -| tst.ts:434:7:445:5 | [BlockStmt] { ... ; } | semmle.label | [BlockStmt] { ... ; } | -| tst.ts:435:9:435:48 | [DeclStmt] const methodName = ... | semmle.label | [DeclStmt] const methodName = ... | -| tst.ts:435:15:435:24 | [VarDecl] methodName | semmle.label | [VarDecl] methodName | -| tst.ts:435:15:435:47 | [VariableDeclarator] methodN ... t.name) | semmle.label | [VariableDeclarator] methodN ... t.name) | -| tst.ts:435:28:435:33 | [VarRef] String | semmle.label | [VarRef] String | -| tst.ts:435:28:435:47 | [CallExpr] String(context.name) | semmle.label | [CallExpr] String(context.name) | -| tst.ts:435:35:435:41 | [VarRef] context | semmle.label | [VarRef] context | -| tst.ts:435:35:435:46 | [DotExpr] context.name | semmle.label | [DotExpr] context.name | -| tst.ts:435:43:435:46 | [Label] name | semmle.label | [Label] name | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | semmle.label | [FunctionDeclStmt] functio ... } | -| tst.ts:437:18:437:34 | [VarDecl] replacementMethod | semmle.label | [VarDecl] replacementMethod | -| tst.ts:437:42:437:45 | [LocalTypeAccess] This | semmle.label | [LocalTypeAccess] This | -| tst.ts:437:51:437:54 | [SimpleParameter] args | semmle.label | [SimpleParameter] args | -| tst.ts:437:57:437:60 | [LocalTypeAccess] Args | semmle.label | [LocalTypeAccess] Args | -| tst.ts:437:64:437:69 | [LocalTypeAccess] Return | semmle.label | [LocalTypeAccess] Return | -| tst.ts:437:71:442:9 | [BlockStmt] { ... } | semmle.label | [BlockStmt] { ... } | -| tst.ts:438:13:438:19 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:438:13:438:23 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:438:13:438:64 | [ExprStmt] console ... me}'.`) | semmle.label | [ExprStmt] console ... me}'.`) | -| tst.ts:438:13:438:64 | [MethodCallExpr] console ... me}'.`) | semmle.label | [MethodCallExpr] console ... me}'.`) | -| tst.ts:438:21:438:23 | [Label] log | semmle.label | [Label] log | -| tst.ts:438:25:438:63 | [TemplateLiteral] `LOG: E ... ame}'.` | semmle.label | [TemplateLiteral] `LOG: E ... ame}'.` | -| tst.ts:438:26:438:47 | [TemplateElement] LOG: En ... ethod ' | semmle.label | [TemplateElement] LOG: En ... ethod ' | -| tst.ts:438:50:438:59 | [VarRef] methodName | semmle.label | [VarRef] methodName | -| tst.ts:438:61:438:62 | [TemplateElement] '. | semmle.label | [TemplateElement] '. | -| tst.ts:439:13:439:54 | [DeclStmt] const result = ... | semmle.label | [DeclStmt] const result = ... | -| tst.ts:439:19:439:24 | [VarDecl] result | semmle.label | [VarDecl] result | -| tst.ts:439:19:439:53 | [VariableDeclarator] result ... ..args) | semmle.label | [VariableDeclarator] result ... ..args) | -| tst.ts:439:28:439:33 | [VarRef] target | semmle.label | [VarRef] target | -| tst.ts:439:28:439:38 | [DotExpr] target.call | semmle.label | [DotExpr] target.call | -| tst.ts:439:28:439:53 | [MethodCallExpr] target. ... ..args) | semmle.label | [MethodCallExpr] target. ... ..args) | -| tst.ts:439:35:439:38 | [Label] call | semmle.label | [Label] call | -| tst.ts:439:40:439:43 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:439:46:439:52 | [SpreadElement] ...args | semmle.label | [SpreadElement] ...args | -| tst.ts:439:49:439:52 | [VarRef] args | semmle.label | [VarRef] args | -| tst.ts:440:13:440:19 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:440:13:440:23 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:440:13:440:63 | [ExprStmt] console ... me}'.`) | semmle.label | [ExprStmt] console ... me}'.`) | -| tst.ts:440:13:440:63 | [MethodCallExpr] console ... me}'.`) | semmle.label | [MethodCallExpr] console ... me}'.`) | -| tst.ts:440:21:440:23 | [Label] log | semmle.label | [Label] log | -| tst.ts:440:25:440:62 | [TemplateLiteral] `LOG: E ... ame}'.` | semmle.label | [TemplateLiteral] `LOG: E ... ame}'.` | -| tst.ts:440:26:440:46 | [TemplateElement] LOG: Ex ... ethod ' | semmle.label | [TemplateElement] LOG: Ex ... ethod ' | -| tst.ts:440:49:440:58 | [VarRef] methodName | semmle.label | [VarRef] methodName | -| tst.ts:440:60:440:61 | [TemplateElement] '. | semmle.label | [TemplateElement] '. | -| tst.ts:441:13:441:26 | [ReturnStmt] return result; | semmle.label | [ReturnStmt] return result; | -| tst.ts:441:20:441:25 | [VarRef] result | semmle.label | [VarRef] result | -| tst.ts:444:9:444:33 | [ReturnStmt] return ... Method; | semmle.label | [ReturnStmt] return ... Method; | -| tst.ts:444:16:444:32 | [VarRef] replacementMethod | semmle.label | [VarRef] replacementMethod | -| tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | semmle.label | [ClassDefinition,TypeDefinition] class P ... } } | -| tst.ts:447:11:447:16 | [VarDecl] Person | semmle.label | [VarDecl] Person | -| tst.ts:448:9:448:12 | [Label] name | semmle.label | [Label] name | -| tst.ts:448:9:448:21 | [FieldDeclaration] name: string; | semmle.label | [FieldDeclaration] name: string; | -| tst.ts:448:15:448:20 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:449:9:451:9 | [ClassInitializedMember,ConstructorDefinition] constru ... } | semmle.label | [ClassInitializedMember,ConstructorDefinition] constru ... } | -| tst.ts:449:9:451:9 | [FunctionExpr] constru ... } | semmle.label | [FunctionExpr] constru ... } | -| tst.ts:449:9:451:9 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:449:21:449:24 | [SimpleParameter] name | semmle.label | [SimpleParameter] name | -| tst.ts:449:27:449:32 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:449:35:451:9 | [BlockStmt] { ... } | semmle.label | [BlockStmt] { ... } | -| tst.ts:450:13:450:16 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:450:13:450:21 | [DotExpr] this.name | semmle.label | [DotExpr] this.name | -| tst.ts:450:13:450:28 | [AssignExpr] this.name = name | semmle.label | [AssignExpr] this.name = name | -| tst.ts:450:13:450:29 | [ExprStmt] this.name = name; | semmle.label | [ExprStmt] this.name = name; | -| tst.ts:450:18:450:21 | [Label] name | semmle.label | [Label] name | -| tst.ts:450:25:450:28 | [VarRef] name | semmle.label | [VarRef] name | -| tst.ts:453:9:453:25 | [Decorator] @loggedMethod("") | semmle.label | [Decorator] @loggedMethod("") | -| tst.ts:453:10:453:21 | [VarRef] loggedMethod | semmle.label | [VarRef] loggedMethod | -| tst.ts:453:10:453:25 | [CallExpr] loggedMethod("") | semmle.label | [CallExpr] loggedMethod("") | -| tst.ts:453:23:453:24 | [Literal] "" | semmle.label | [Literal] "" | -| tst.ts:454:9:454:13 | [Label] greet | semmle.label | [Label] greet | -| tst.ts:454:9:457:9 | [ClassInitializedMember,MethodDefinition] greet() ... } | semmle.label | [ClassInitializedMember,MethodDefinition] greet() ... } | -| tst.ts:454:9:457:9 | [FunctionExpr] greet() ... } | semmle.label | [FunctionExpr] greet() ... } | -| tst.ts:454:17:457:9 | [BlockStmt] { ... } | semmle.label | [BlockStmt] { ... } | -| tst.ts:455:13:455:19 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:455:13:455:23 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:455:13:455:58 | [MethodCallExpr] console ... ame}.`) | semmle.label | [MethodCallExpr] console ... ame}.`) | -| tst.ts:455:13:455:59 | [ExprStmt] console ... me}.`); | semmle.label | [ExprStmt] console ... me}.`); | -| tst.ts:455:21:455:23 | [Label] log | semmle.label | [Label] log | -| tst.ts:455:25:455:57 | [TemplateLiteral] `Hello, ... name}.` | semmle.label | [TemplateLiteral] `Hello, ... name}.` | -| tst.ts:455:26:455:43 | [TemplateElement] Hello, my name is | semmle.label | [TemplateElement] Hello, my name is | -| tst.ts:455:46:455:49 | [ThisExpr] this | semmle.label | [ThisExpr] this | -| tst.ts:455:46:455:54 | [DotExpr] this.name | semmle.label | [DotExpr] this.name | -| tst.ts:455:51:455:54 | [Label] name | semmle.label | [Label] name | -| tst.ts:455:56:455:56 | [TemplateElement] . | semmle.label | [TemplateElement] . | -| tst.ts:456:13:456:21 | [ReturnStmt] return 2; | semmle.label | [ReturnStmt] return 2; | -| tst.ts:456:20:456:20 | [Literal] 2 | semmle.label | [Literal] 2 | -| tst.ts:460:5:460:41 | [DeclStmt] const p = ... | semmle.label | [DeclStmt] const p = ... | -| tst.ts:460:11:460:11 | [VarDecl] p | semmle.label | [VarDecl] p | -| tst.ts:460:11:460:40 | [VariableDeclarator] p = new ... greet() | semmle.label | [VariableDeclarator] p = new ... greet() | -| tst.ts:460:15:460:32 | [NewExpr] new Person("John") | semmle.label | [NewExpr] new Person("John") | -| tst.ts:460:15:460:38 | [DotExpr] new Per ... ).greet | semmle.label | [DotExpr] new Per ... ).greet | -| tst.ts:460:15:460:40 | [MethodCallExpr] new Per ... greet() | semmle.label | [MethodCallExpr] new Per ... greet() | -| tst.ts:460:19:460:24 | [VarRef] Person | semmle.label | [VarRef] Person | -| tst.ts:460:26:460:31 | [Literal] "John" | semmle.label | [Literal] "John" | -| tst.ts:460:34:460:38 | [Label] greet | semmle.label | [Label] greet | -| tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | semmle.label | [FunctionDeclStmt] declare ... T): T; | -| tst.ts:462:22:462:38 | [VarDecl] myConstIdFunction | semmle.label | [VarDecl] myConstIdFunction | -| tst.ts:462:40:462:72 | [TypeParameter] const T ... tring[] | semmle.label | [TypeParameter] const T ... tring[] | -| tst.ts:462:46:462:46 | [Identifier] T | semmle.label | [Identifier] T | -| tst.ts:462:56:462:72 | [ReadonlyTypeExpr] readonly string[] | semmle.label | [ReadonlyTypeExpr] readonly string[] | -| tst.ts:462:65:462:70 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:462:65:462:72 | [ArrayTypeExpr] string[] | semmle.label | [ArrayTypeExpr] string[] | -| tst.ts:462:75:462:78 | [SimpleParameter] args | semmle.label | [SimpleParameter] args | -| tst.ts:462:81:462:81 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:462:85:462:85 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:465:5:465:51 | [DeclStmt] const foo = ... | semmle.label | [DeclStmt] const foo = ... | -| tst.ts:465:11:465:13 | [VarDecl] foo | semmle.label | [VarDecl] foo | -| tst.ts:465:11:465:50 | [VariableDeclarator] foo = m ... ,"c"]) | semmle.label | [VariableDeclarator] foo = m ... ,"c"]) | -| tst.ts:465:17:465:33 | [VarRef] myConstIdFunction | semmle.label | [VarRef] myConstIdFunction | -| tst.ts:465:17:465:50 | [CallExpr] myConst ... ,"c"]) | semmle.label | [CallExpr] myConst ... ,"c"]) | -| tst.ts:465:35:465:49 | [ArrayExpr] ["a", "b" ,"c"] | semmle.label | [ArrayExpr] ["a", "b" ,"c"] | -| tst.ts:465:36:465:38 | [Literal] "a" | semmle.label | [Literal] "a" | -| tst.ts:465:41:465:43 | [Literal] "b" | semmle.label | [Literal] "b" | -| tst.ts:465:46:465:48 | [Literal] "c" | semmle.label | [Literal] "c" | -| tst.ts:467:5:467:21 | [DeclStmt] const b = ... | semmle.label | [DeclStmt] const b = ... | -| tst.ts:467:11:467:11 | [VarDecl] b | semmle.label | [VarDecl] b | -| tst.ts:467:11:467:20 | [VariableDeclarator] b = foo[1] | semmle.label | [VariableDeclarator] b = foo[1] | -| tst.ts:467:15:467:17 | [VarRef] foo | semmle.label | [VarRef] foo | -| tst.ts:467:15:467:20 | [IndexExpr] foo[1] | semmle.label | [IndexExpr] foo[1] | -| tst.ts:467:19:467:19 | [Literal] 1 | semmle.label | [Literal] 1 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | semmle.label | [NamespaceDeclaration] module ... ng>); } | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | semmle.order | 90 | -| tst.ts:472:8:472:11 | [VarDecl] TS52 | semmle.label | [VarDecl] TS52 | -| tst.ts:473:5:476:5 | [ClassDefinition,TypeDefinition] class S ... ; } | semmle.label | [ClassDefinition,TypeDefinition] class S ... ; } | -| tst.ts:473:11:473:19 | [VarDecl] SomeClass | semmle.label | [VarDecl] SomeClass | -| tst.ts:473:21:473:20 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:473:21:473:20 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | [ClassInitializedMember,ConstructorDefinition] constructor() {} | -| tst.ts:473:21:473:20 | [FunctionExpr] () {} | semmle.label | [FunctionExpr] () {} | -| tst.ts:473:21:473:20 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:474:9:474:36 | [Decorator] @((_tar ... => {}) | semmle.label | [Decorator] @((_tar ... => {}) | -| tst.ts:474:10:474:36 | [ParExpr] ((_targ ... => {}) | semmle.label | [ParExpr] ((_targ ... => {}) | -| tst.ts:474:11:474:35 | [ArrowFunctionExpr] (_targe ... ) => {} | semmle.label | [ArrowFunctionExpr] (_targe ... ) => {} | -| tst.ts:474:12:474:18 | [SimpleParameter] _target | semmle.label | [SimpleParameter] _target | -| tst.ts:474:21:474:28 | [SimpleParameter] _context | semmle.label | [SimpleParameter] _context | -| tst.ts:474:34:474:35 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:475:9:475:11 | [Label] foo | semmle.label | [Label] foo | -| tst.ts:475:9:475:18 | [FieldDeclaration] foo = 123; | semmle.label | [FieldDeclaration] foo = 123; | -| tst.ts:475:15:475:17 | [Literal] 123 | semmle.label | [Literal] 123 | -| tst.ts:478:5:478:11 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:478:5:478:15 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:478:5:478:43 | [MethodCallExpr] console ... adata]) | semmle.label | [MethodCallExpr] console ... adata]) | -| tst.ts:478:5:478:44 | [ExprStmt] console ... data]); | semmle.label | [ExprStmt] console ... data]); | -| tst.ts:478:13:478:15 | [Label] log | semmle.label | [Label] log | -| tst.ts:478:17:478:25 | [VarRef] SomeClass | semmle.label | [VarRef] SomeClass | -| tst.ts:478:17:478:42 | [IndexExpr] SomeCla ... tadata] | semmle.label | [IndexExpr] SomeCla ... tadata] | -| tst.ts:478:27:478:32 | [VarRef] Symbol | semmle.label | [VarRef] Symbol | -| tst.ts:478:27:478:41 | [DotExpr] Symbol.metadata | semmle.label | [DotExpr] Symbol.metadata | -| tst.ts:478:34:478:41 | [Label] metadata | semmle.label | [Label] metadata | -| tst.ts:481:5:481:34 | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | -| tst.ts:481:10:481:14 | [Identifier] Pair3 | semmle.label | [Identifier] Pair3 | -| tst.ts:481:16:481:16 | [Identifier] T | semmle.label | [Identifier] T | -| tst.ts:481:16:481:16 | [TypeParameter] T | semmle.label | [TypeParameter] T | -| tst.ts:481:21:481:33 | [TupleTypeExpr] [first: T, T] | semmle.label | [TupleTypeExpr] [first: T, T] | -| tst.ts:481:22:481:26 | [Identifier] first | semmle.label | [Identifier] first | -| tst.ts:481:29:481:29 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:481:32:481:32 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| tst.ts:483:5:483:11 | [VarRef] console | semmle.label | [VarRef] console | -| tst.ts:483:5:483:15 | [DotExpr] console.log | semmle.label | [DotExpr] console.log | -| tst.ts:483:5:483:59 | [MethodCallExpr] console ... tring>) | semmle.label | [MethodCallExpr] console ... tring>) | -| tst.ts:483:5:483:60 | [ExprStmt] console ... ring>); | semmle.label | [ExprStmt] console ... ring>); | -| tst.ts:483:13:483:15 | [Label] log | semmle.label | [Label] log | -| tst.ts:483:17:483:34 | [ArrayExpr] ["hello", "world"] | semmle.label | [ArrayExpr] ["hello", "world"] | -| tst.ts:483:17:483:58 | [SatisfiesExpr] ["hello ... string> | semmle.label | [SatisfiesExpr] ["hello ... string> | -| tst.ts:483:18:483:24 | [Literal] "hello" | semmle.label | [Literal] "hello" | -| tst.ts:483:27:483:33 | [Literal] "world" | semmle.label | [Literal] "world" | -| tst.ts:483:46:483:50 | [LocalTypeAccess] Pair3 | semmle.label | [LocalTypeAccess] Pair3 | -| tst.ts:483:46:483:58 | [GenericTypeExpr] Pair3 | semmle.label | [GenericTypeExpr] Pair3 | -| tst.ts:483:52:483:57 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | semmle.label | [NamespaceDeclaration] module ... }); } | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | semmle.order | 91 | -| tst.ts:486:8:486:11 | [VarDecl] TS54 | semmle.label | [VarDecl] TS54 | -| tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | semmle.label | [FunctionDeclStmt] functio ... 0]; } | -| tst.ts:487:12:487:28 | [VarDecl] createStreetLight | semmle.label | [VarDecl] createStreetLight | -| tst.ts:487:30:487:30 | [Identifier] C | semmle.label | [Identifier] C | -| tst.ts:487:30:487:45 | [TypeParameter] C extends string | semmle.label | [TypeParameter] C extends string | -| tst.ts:487:40:487:45 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:487:48:487:53 | [SimpleParameter] colors | semmle.label | [SimpleParameter] colors | -| tst.ts:487:56:487:56 | [LocalTypeAccess] C | semmle.label | [LocalTypeAccess] C | -| tst.ts:487:56:487:58 | [ArrayTypeExpr] C[] | semmle.label | [ArrayTypeExpr] C[] | -| tst.ts:487:61:487:72 | [SimpleParameter] defaultColor | semmle.label | [SimpleParameter] defaultColor | -| tst.ts:487:76:487:82 | [LocalTypeAccess] NoInfer | semmle.label | [LocalTypeAccess] NoInfer | -| tst.ts:487:76:487:85 | [GenericTypeExpr] NoInfer | semmle.label | [GenericTypeExpr] NoInfer | -| tst.ts:487:84:487:84 | [LocalTypeAccess] C | semmle.label | [LocalTypeAccess] C | -| tst.ts:487:88:489:3 | [BlockStmt] { r ... 0]; } | semmle.label | [BlockStmt] { r ... 0]; } | -| tst.ts:488:5:488:21 | [ReturnStmt] return colors[0]; | semmle.label | [ReturnStmt] return colors[0]; | -| tst.ts:488:12:488:17 | [VarRef] colors | semmle.label | [VarRef] colors | -| tst.ts:488:12:488:20 | [IndexExpr] colors[0] | semmle.label | [IndexExpr] colors[0] | -| tst.ts:488:19:488:19 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:491:3:491:19 | [VarRef] createStreetLight | semmle.label | [VarRef] createStreetLight | -| tst.ts:491:3:491:57 | [CallExpr] createS ... ellow") | semmle.label | [CallExpr] createS ... ellow") | -| tst.ts:491:3:491:58 | [ExprStmt] createS ... llow"); | semmle.label | [ExprStmt] createS ... llow"); | -| tst.ts:491:21:491:46 | [ArrayExpr] ["red", ... green"] | semmle.label | [ArrayExpr] ["red", ... green"] | -| tst.ts:491:22:491:26 | [Literal] "red" | semmle.label | [Literal] "red" | -| tst.ts:491:29:491:36 | [Literal] "yellow" | semmle.label | [Literal] "yellow" | -| tst.ts:491:39:491:45 | [Literal] "green" | semmle.label | [Literal] "green" | -| tst.ts:491:49:491:56 | [Literal] "yellow" | semmle.label | [Literal] "yellow" | -| tst.ts:493:3:495:5 | [DeclStmt] const myObj = ... | semmle.label | [DeclStmt] const myObj = ... | -| tst.ts:493:9:493:13 | [VarDecl] myObj | semmle.label | [VarDecl] myObj | -| tst.ts:493:9:495:4 | [VariableDeclarator] myObj = ... "; }) | semmle.label | [VariableDeclarator] myObj = ... "; }) | -| tst.ts:493:17:493:22 | [VarRef] Object | semmle.label | [VarRef] Object | -| tst.ts:493:17:493:30 | [DotExpr] Object.groupBy | semmle.label | [DotExpr] Object.groupBy | -| tst.ts:493:17:495:4 | [MethodCallExpr] Object. ... "; }) | semmle.label | [MethodCallExpr] Object. ... "; }) | -| tst.ts:493:24:493:30 | [Label] groupBy | semmle.label | [Label] groupBy | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | semmle.label | [ArrayExpr] [0, 1, 2, 3, 4, 5] | -| tst.ts:493:33:493:33 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:493:36:493:36 | [Literal] 1 | semmle.label | [Literal] 1 | -| tst.ts:493:39:493:39 | [Literal] 2 | semmle.label | [Literal] 2 | -| tst.ts:493:42:493:42 | [Literal] 3 | semmle.label | [Literal] 3 | -| tst.ts:493:45:493:45 | [Literal] 4 | semmle.label | [Literal] 4 | -| tst.ts:493:48:493:48 | [Literal] 5 | semmle.label | [Literal] 5 | -| tst.ts:493:52:495:3 | [ArrowFunctionExpr] (num, i ... d"; } | semmle.label | [ArrowFunctionExpr] (num, i ... d"; } | -| tst.ts:493:53:493:55 | [SimpleParameter] num | semmle.label | [SimpleParameter] num | -| tst.ts:493:58:493:62 | [SimpleParameter] index | semmle.label | [SimpleParameter] index | -| tst.ts:493:68:495:3 | [BlockStmt] { r ... d"; } | semmle.label | [BlockStmt] { r ... d"; } | -| tst.ts:494:5:494:41 | [ReturnStmt] return ... "odd"; | semmle.label | [ReturnStmt] return ... "odd"; | -| tst.ts:494:12:494:14 | [VarRef] num | semmle.label | [VarRef] num | -| tst.ts:494:12:494:18 | [BinaryExpr] num % 2 | semmle.label | [BinaryExpr] num % 2 | -| tst.ts:494:12:494:24 | [BinaryExpr] num % 2 === 0 | semmle.label | [BinaryExpr] num % 2 === 0 | -| tst.ts:494:12:494:40 | [ConditionalExpr] num % 2 ... : "odd" | semmle.label | [ConditionalExpr] num % 2 ... : "odd" | -| tst.ts:494:18:494:18 | [Literal] 2 | semmle.label | [Literal] 2 | -| tst.ts:494:24:494:24 | [Literal] 0 | semmle.label | [Literal] 0 | -| tst.ts:494:28:494:33 | [Literal] "even" | semmle.label | [Literal] "even" | -| tst.ts:494:36:494:40 | [Literal] "odd" | semmle.label | [Literal] "odd" | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | semmle.label | [NamespaceDeclaration] module ... } } } | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | semmle.order | 92 | -| tst.ts:498:8:498:11 | [VarDecl] TS55 | semmle.label | [VarDecl] TS55 | -| tst.ts:499:3:500:40 | [DeclStmt] const strings = ... | semmle.label | [DeclStmt] const strings = ... | -| tst.ts:499:9:499:15 | [VarDecl] strings | semmle.label | [VarDecl] strings | -| tst.ts:499:9:500:39 | [VariableDeclarator] strings ... tring") | semmle.label | [VariableDeclarator] strings ... tring") | -| tst.ts:499:19:499:32 | [ParExpr] (["foo", 123]) | semmle.label | [ParExpr] (["foo", 123]) | -| tst.ts:499:19:500:11 | [DotExpr] (["foo" ... .filter | semmle.label | [DotExpr] (["foo" ... .filter | -| tst.ts:499:19:500:39 | [MethodCallExpr] (["foo" ... tring") | semmle.label | [MethodCallExpr] (["foo" ... tring") | -| tst.ts:499:20:499:31 | [ArrayExpr] ["foo", 123] | semmle.label | [ArrayExpr] ["foo", 123] | -| tst.ts:499:21:499:25 | [Literal] "foo" | semmle.label | [Literal] "foo" | -| tst.ts:499:28:499:30 | [Literal] 123 | semmle.label | [Literal] 123 | -| tst.ts:500:6:500:11 | [Label] filter | semmle.label | [Label] filter | -| tst.ts:500:13:500:13 | [SimpleParameter] s | semmle.label | [SimpleParameter] s | -| tst.ts:500:13:500:38 | [ArrowFunctionExpr] s => ty ... string" | semmle.label | [ArrowFunctionExpr] s => ty ... string" | -| tst.ts:500:18:500:25 | [UnaryExpr] typeof s | semmle.label | [UnaryExpr] typeof s | -| tst.ts:500:18:500:38 | [BinaryExpr] typeof ... string" | semmle.label | [BinaryExpr] typeof ... string" | -| tst.ts:500:25:500:25 | [VarRef] s | semmle.label | [VarRef] s | -| tst.ts:500:31:500:38 | [Literal] "string" | semmle.label | [Literal] "string" | -| tst.ts:502:3:504:3 | [ForOfStmt] for (co ... 5.4 } | semmle.label | [ForOfStmt] for (co ... 5.4 } | -| tst.ts:502:8:502:16 | [DeclStmt] const str = ... | semmle.label | [DeclStmt] const str = ... | -| tst.ts:502:14:502:16 | [VarDecl] str | semmle.label | [VarDecl] str | -| tst.ts:502:14:502:16 | [VariableDeclarator] str | semmle.label | [VariableDeclarator] str | -| tst.ts:502:21:502:27 | [VarRef] strings | semmle.label | [VarRef] strings | -| tst.ts:502:30:504:3 | [BlockStmt] { s ... 5.4 } | semmle.label | [BlockStmt] { s ... 5.4 } | -| tst.ts:503:5:503:7 | [VarRef] str | semmle.label | [VarRef] str | -| tst.ts:503:5:503:19 | [DotExpr] str.toLowerCase | semmle.label | [DotExpr] str.toLowerCase | -| tst.ts:503:5:503:21 | [MethodCallExpr] str.toLowerCase() | semmle.label | [MethodCallExpr] str.toLowerCase() | -| tst.ts:503:5:503:22 | [ExprStmt] str.toLowerCase(); | semmle.label | [ExprStmt] str.toLowerCase(); | -| tst.ts:503:9:503:19 | [Label] toLowerCase | semmle.label | [Label] toLowerCase | -| tst.ts:506:3:510:3 | [FunctionDeclStmt] functio ... } } | semmle.label | [FunctionDeclStmt] functio ... } } | -| tst.ts:506:12:506:13 | [VarDecl] f1 | semmle.label | [VarDecl] f1 | -| tst.ts:506:15:506:17 | [SimpleParameter] obj | semmle.label | [SimpleParameter] obj | -| tst.ts:506:20:506:25 | [LocalTypeAccess] Record | semmle.label | [LocalTypeAccess] Record | -| tst.ts:506:20:506:42 | [GenericTypeExpr] Record< ... nknown> | semmle.label | [GenericTypeExpr] Record< ... nknown> | -| tst.ts:506:27:506:32 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:506:35:506:41 | [KeywordTypeExpr] unknown | semmle.label | [KeywordTypeExpr] unknown | -| tst.ts:506:45:506:47 | [SimpleParameter] key | semmle.label | [SimpleParameter] key | -| tst.ts:506:50:506:55 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| tst.ts:506:58:510:3 | [BlockStmt] { i ... } } | semmle.label | [BlockStmt] { i ... } } | -| tst.ts:507:5:509:5 | [IfStmt] if (typ ... r } | semmle.label | [IfStmt] if (typ ... r } | -| tst.ts:507:9:507:23 | [UnaryExpr] typeof obj[key] | semmle.label | [UnaryExpr] typeof obj[key] | -| tst.ts:507:9:507:36 | [BinaryExpr] typeof ... string" | semmle.label | [BinaryExpr] typeof ... string" | -| tst.ts:507:16:507:18 | [VarRef] obj | semmle.label | [VarRef] obj | -| tst.ts:507:16:507:23 | [IndexExpr] obj[key] | semmle.label | [IndexExpr] obj[key] | -| tst.ts:507:20:507:22 | [VarRef] key | semmle.label | [VarRef] key | -| tst.ts:507:29:507:36 | [Literal] "string" | semmle.label | [Literal] "string" | -| tst.ts:507:39:509:5 | [BlockStmt] { ... r } | semmle.label | [BlockStmt] { ... r } | -| tst.ts:508:7:508:39 | [DeclStmt] var str = ... | semmle.label | [DeclStmt] var str = ... | -| tst.ts:508:11:508:13 | [VarDecl] str | semmle.label | [VarDecl] str | -| tst.ts:508:11:508:38 | [VariableDeclarator] str = o ... rCase() | semmle.label | [VariableDeclarator] str = o ... rCase() | -| tst.ts:508:17:508:19 | [VarRef] obj | semmle.label | [VarRef] obj | -| tst.ts:508:17:508:24 | [IndexExpr] obj[key] | semmle.label | [IndexExpr] obj[key] | -| tst.ts:508:17:508:36 | [DotExpr] obj[key].toUpperCase | semmle.label | [DotExpr] obj[key].toUpperCase | -| tst.ts:508:17:508:38 | [MethodCallExpr] obj[key ... rCase() | semmle.label | [MethodCallExpr] obj[key ... rCase() | -| tst.ts:508:21:508:23 | [VarRef] key | semmle.label | [VarRef] key | -| tst.ts:508:26:508:36 | [Label] toUpperCase | semmle.label | [Label] toUpperCase | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | semmle.label | [NamespaceDeclaration] namespa ... type. } | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | semmle.order | 93 | -| tst.ts:513:11:513:14 | [VarDecl] TS57 | semmle.label | [VarDecl] TS57 | -| tst.ts:514:3:514:26 | [DeclStmt] const a = ... | semmle.label | [DeclStmt] const a = ... | -| tst.ts:514:17:514:17 | [VarDecl] a | semmle.label | [VarDecl] a | -| tst.ts:514:17:514:25 | [VariableDeclarator] a: symbol | semmle.label | [VariableDeclarator] a: symbol | -| tst.ts:514:20:514:25 | [KeywordTypeExpr] symbol | semmle.label | [KeywordTypeExpr] symbol | -| tst.ts:515:3:517:3 | [ExportDeclaration] export ... }; } | semmle.label | [ExportDeclaration] export ... }; } | -| tst.ts:515:10:517:3 | [ClassDefinition,TypeDefinition] class A ... }; } | semmle.label | [ClassDefinition,TypeDefinition] class A ... }; } | -| tst.ts:515:16:515:16 | [VarDecl] A | semmle.label | [VarDecl] A | -| tst.ts:515:18:515:17 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| tst.ts:515:18:515:17 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | [ClassInitializedMember,ConstructorDefinition] constructor() {} | -| tst.ts:515:18:515:17 | [FunctionExpr] () {} | semmle.label | [FunctionExpr] () {} | -| tst.ts:515:18:515:17 | [Label] constructor | semmle.label | [Label] constructor | -| tst.ts:516:7:516:24 | [ClassInitializedMember,MethodDefinition] [a]() { return 1 } | semmle.label | [ClassInitializedMember,MethodDefinition] [a]() { return 1 } | -| tst.ts:516:7:516:24 | [FunctionExpr] [a]() { return 1 } | semmle.label | [FunctionExpr] [a]() { return 1 } | -| tst.ts:516:8:516:8 | [VarRef] a | semmle.label | [VarRef] a | -| tst.ts:516:13:516:24 | [BlockStmt] { return 1 } | semmle.label | [BlockStmt] { return 1 } | -| tst.ts:516:15:516:22 | [ReturnStmt] return 1 | semmle.label | [ReturnStmt] return 1 | -| tst.ts:516:22:516:22 | [Literal] 1 | semmle.label | [Literal] 1 | -| tst.ts:519:3:519:32 | [DeclStmt] const e1 = ... | semmle.label | [DeclStmt] const e1 = ... | -| tst.ts:519:17:519:18 | [VarDecl] e1 | semmle.label | [VarDecl] e1 | -| tst.ts:519:17:519:31 | [VariableDeclarator] e1: A[typeof a] | semmle.label | [VariableDeclarator] e1: A[typeof a] | -| tst.ts:519:21:519:21 | [LocalTypeAccess] A | semmle.label | [LocalTypeAccess] A | -| tst.ts:519:21:519:31 | [IndexedAccessTypeExpr] A[typeof a] | semmle.label | [IndexedAccessTypeExpr] A[typeof a] | -| tst.ts:519:23:519:30 | [TypeofTypeExpr] typeof a | semmle.label | [TypeofTypeExpr] typeof a | -| tst.ts:519:30:519:30 | [LocalVarTypeAccess] a | semmle.label | [LocalVarTypeAccess] a | -| tstModuleCJS.cts:1:1:3:1 | [ExportDeclaration] export ... 'b'; } | semmle.label | [ExportDeclaration] export ... 'b'; } | -| tstModuleCJS.cts:1:1:3:1 | [ExportDeclaration] export ... 'b'; } | semmle.order | 94 | -| tstModuleCJS.cts:1:8:3:1 | [FunctionDeclStmt] functio ... 'b'; } | semmle.label | [FunctionDeclStmt] functio ... 'b'; } | -| tstModuleCJS.cts:1:17:1:28 | [VarDecl] tstModuleCJS | semmle.label | [VarDecl] tstModuleCJS | -| tstModuleCJS.cts:1:33:1:35 | [LiteralTypeExpr] 'a' | semmle.label | [LiteralTypeExpr] 'a' | -| tstModuleCJS.cts:1:33:1:41 | [UnionTypeExpr] 'a' \| 'b' | semmle.label | [UnionTypeExpr] 'a' \| 'b' | -| tstModuleCJS.cts:1:39:1:41 | [LiteralTypeExpr] 'b' | semmle.label | [LiteralTypeExpr] 'b' | -| tstModuleCJS.cts:1:43:3:1 | [BlockStmt] { r ... 'b'; } | semmle.label | [BlockStmt] { r ... 'b'; } | -| tstModuleCJS.cts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | semmle.label | [ReturnStmt] return ... : 'b'; | -| tstModuleCJS.cts:2:12:2:15 | [VarRef] Math | semmle.label | [VarRef] Math | -| tstModuleCJS.cts:2:12:2:22 | [DotExpr] Math.random | semmle.label | [DotExpr] Math.random | -| tstModuleCJS.cts:2:12:2:24 | [MethodCallExpr] Math.random() | semmle.label | [MethodCallExpr] Math.random() | -| tstModuleCJS.cts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | semmle.label | [BinaryExpr] Math.random() > 0.5 | -| tstModuleCJS.cts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | semmle.label | [ConditionalExpr] Math.ra ... ' : 'b' | -| tstModuleCJS.cts:2:17:2:22 | [Label] random | semmle.label | [Label] random | -| tstModuleCJS.cts:2:28:2:30 | [Literal] 0.5 | semmle.label | [Literal] 0.5 | -| tstModuleCJS.cts:2:34:2:36 | [Literal] 'a' | semmle.label | [Literal] 'a' | -| tstModuleCJS.cts:2:40:2:42 | [Literal] 'b' | semmle.label | [Literal] 'b' | -| tstModuleES.mts:1:1:3:1 | [ExportDeclaration] export ... 'b'; } | semmle.label | [ExportDeclaration] export ... 'b'; } | -| tstModuleES.mts:1:1:3:1 | [ExportDeclaration] export ... 'b'; } | semmle.order | 95 | -| tstModuleES.mts:1:16:3:1 | [FunctionDeclStmt] functio ... 'b'; } | semmle.label | [FunctionDeclStmt] functio ... 'b'; } | -| tstModuleES.mts:1:25:1:35 | [VarDecl] tstModuleES | semmle.label | [VarDecl] tstModuleES | -| tstModuleES.mts:1:40:1:42 | [LiteralTypeExpr] 'a' | semmle.label | [LiteralTypeExpr] 'a' | -| tstModuleES.mts:1:40:1:48 | [UnionTypeExpr] 'a' \| 'b' | semmle.label | [UnionTypeExpr] 'a' \| 'b' | -| tstModuleES.mts:1:46:1:48 | [LiteralTypeExpr] 'b' | semmle.label | [LiteralTypeExpr] 'b' | -| tstModuleES.mts:1:50:3:1 | [BlockStmt] { r ... 'b'; } | semmle.label | [BlockStmt] { r ... 'b'; } | -| tstModuleES.mts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | semmle.label | [ReturnStmt] return ... : 'b'; | -| tstModuleES.mts:2:12:2:15 | [VarRef] Math | semmle.label | [VarRef] Math | -| tstModuleES.mts:2:12:2:22 | [DotExpr] Math.random | semmle.label | [DotExpr] Math.random | -| tstModuleES.mts:2:12:2:24 | [MethodCallExpr] Math.random() | semmle.label | [MethodCallExpr] Math.random() | -| tstModuleES.mts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | semmle.label | [BinaryExpr] Math.random() > 0.5 | -| tstModuleES.mts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | semmle.label | [ConditionalExpr] Math.ra ... ' : 'b' | -| tstModuleES.mts:2:17:2:22 | [Label] random | semmle.label | [Label] random | -| tstModuleES.mts:2:28:2:30 | [Literal] 0.5 | semmle.label | [Literal] 0.5 | -| tstModuleES.mts:2:34:2:36 | [Literal] 'a' | semmle.label | [Literal] 'a' | -| tstModuleES.mts:2:40:2:42 | [Literal] 'b' | semmle.label | [Literal] 'b' | -| tstSuffixA.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | semmle.label | [ExportDeclaration] export ... .ts'; } | -| tstSuffixA.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | semmle.order | 96 | -| tstSuffixA.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | semmle.label | [FunctionDeclStmt] functio ... .ts'; } | -| tstSuffixA.ts:1:17:1:28 | [VarDecl] resolvedFile | semmle.label | [VarDecl] resolvedFile | -| tstSuffixA.ts:1:33:1:47 | [LiteralTypeExpr] 'tstSuffixA.ts' | semmle.label | [LiteralTypeExpr] 'tstSuffixA.ts' | -| tstSuffixA.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | semmle.label | [BlockStmt] { r ... .ts'; } | -| tstSuffixA.ts:2:5:2:27 | [ReturnStmt] return ... xA.ts'; | semmle.label | [ReturnStmt] return ... xA.ts'; | -| tstSuffixA.ts:2:12:2:26 | [Literal] 'tstSuffixA.ts' | semmle.label | [Literal] 'tstSuffixA.ts' | -| tstSuffixB.ios.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | semmle.label | [ExportDeclaration] export ... .ts'; } | -| tstSuffixB.ios.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | semmle.order | 97 | -| tstSuffixB.ios.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | semmle.label | [FunctionDeclStmt] functio ... .ts'; } | -| tstSuffixB.ios.ts:1:17:1:28 | [VarDecl] resolvedFile | semmle.label | [VarDecl] resolvedFile | -| tstSuffixB.ios.ts:1:33:1:51 | [LiteralTypeExpr] 'tstSuffixB.ios.ts' | semmle.label | [LiteralTypeExpr] 'tstSuffixB.ios.ts' | -| tstSuffixB.ios.ts:1:53:3:1 | [BlockStmt] { r ... .ts'; } | semmle.label | [BlockStmt] { r ... .ts'; } | -| tstSuffixB.ios.ts:2:5:2:31 | [ReturnStmt] return ... os.ts'; | semmle.label | [ReturnStmt] return ... os.ts'; | -| tstSuffixB.ios.ts:2:12:2:30 | [Literal] 'tstSuffixB.ios.ts' | semmle.label | [Literal] 'tstSuffixB.ios.ts' | -| tstSuffixB.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | semmle.label | [ExportDeclaration] export ... .ts'; } | -| tstSuffixB.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | semmle.order | 98 | -| tstSuffixB.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | semmle.label | [FunctionDeclStmt] functio ... .ts'; } | -| tstSuffixB.ts:1:17:1:28 | [VarDecl] resolvedFile | semmle.label | [VarDecl] resolvedFile | -| tstSuffixB.ts:1:33:1:47 | [LiteralTypeExpr] 'tstSuffixB.ts' | semmle.label | [LiteralTypeExpr] 'tstSuffixB.ts' | -| tstSuffixB.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | semmle.label | [BlockStmt] { r ... .ts'; } | -| tstSuffixB.ts:2:5:2:27 | [ReturnStmt] return ... xB.ts'; | semmle.label | [ReturnStmt] return ... xB.ts'; | -| tstSuffixB.ts:2:12:2:26 | [Literal] 'tstSuffixB.ts' | semmle.label | [Literal] 'tstSuffixB.ts' | -| type_alias.ts:1:1:1:17 | [TypeAliasDeclaration,TypeDefinition] type B = boolean; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type B = boolean; | -| type_alias.ts:1:1:1:17 | [TypeAliasDeclaration,TypeDefinition] type B = boolean; | semmle.order | 99 | -| type_alias.ts:1:6:1:6 | [Identifier] B | semmle.label | [Identifier] B | -| type_alias.ts:1:10:1:16 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| type_alias.ts:3:1:3:9 | [DeclStmt] var b = ... | semmle.label | [DeclStmt] var b = ... | -| type_alias.ts:3:1:3:9 | [DeclStmt] var b = ... | semmle.order | 100 | -| type_alias.ts:3:5:3:5 | [VarDecl] b | semmle.label | [VarDecl] b | -| type_alias.ts:3:5:3:8 | [VariableDeclarator] b: B | semmle.label | [VariableDeclarator] b: B | -| type_alias.ts:3:8:3:8 | [LocalTypeAccess] B | semmle.label | [LocalTypeAccess] B | -| type_alias.ts:5:1:5:50 | [TypeAliasDeclaration,TypeDefinition] type Va ... ay>; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Va ... ay>; | -| type_alias.ts:5:1:5:50 | [TypeAliasDeclaration,TypeDefinition] type Va ... ay>; | semmle.order | 101 | -| type_alias.ts:5:6:5:17 | [Identifier] ValueOrArray | semmle.label | [Identifier] ValueOrArray | -| type_alias.ts:5:19:5:19 | [Identifier] T | semmle.label | [Identifier] T | -| type_alias.ts:5:19:5:19 | [TypeParameter] T | semmle.label | [TypeParameter] T | -| type_alias.ts:5:24:5:24 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| type_alias.ts:5:24:5:49 | [UnionTypeExpr] T \| Arr ... ray> | semmle.label | [UnionTypeExpr] T \| Arr ... ray> | -| type_alias.ts:5:28:5:32 | [LocalTypeAccess] Array | semmle.label | [LocalTypeAccess] Array | -| type_alias.ts:5:28:5:49 | [GenericTypeExpr] Array> | semmle.label | [GenericTypeExpr] Array> | -| type_alias.ts:5:34:5:45 | [LocalTypeAccess] ValueOrArray | semmle.label | [LocalTypeAccess] ValueOrArray | -| type_alias.ts:5:34:5:48 | [GenericTypeExpr] ValueOrArray | semmle.label | [GenericTypeExpr] ValueOrArray | -| type_alias.ts:5:47:5:47 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| type_alias.ts:7:1:7:28 | [DeclStmt] var c = ... | semmle.label | [DeclStmt] var c = ... | -| type_alias.ts:7:1:7:28 | [DeclStmt] var c = ... | semmle.order | 102 | -| type_alias.ts:7:5:7:5 | [VarDecl] c | semmle.label | [VarDecl] c | -| type_alias.ts:7:5:7:27 | [VariableDeclarator] c: Valu ... number> | semmle.label | [VariableDeclarator] c: Valu ... number> | -| type_alias.ts:7:8:7:19 | [LocalTypeAccess] ValueOrArray | semmle.label | [LocalTypeAccess] ValueOrArray | -| type_alias.ts:7:8:7:27 | [GenericTypeExpr] ValueOrArray | semmle.label | [GenericTypeExpr] ValueOrArray | -| type_alias.ts:7:21:7:26 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| type_alias.ts:9:1:15:13 | [TypeAliasDeclaration,TypeDefinition] type Js ... Json[]; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Js ... Json[]; | -| type_alias.ts:9:1:15:13 | [TypeAliasDeclaration,TypeDefinition] type Js ... Json[]; | semmle.order | 103 | -| type_alias.ts:9:6:9:9 | [Identifier] Json | semmle.label | [Identifier] Json | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | semmle.label | [UnionTypeExpr] \| strin ... Json[] | -| type_alias.ts:10:7:10:12 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| type_alias.ts:11:7:11:12 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| type_alias.ts:12:7:12:13 | [KeywordTypeExpr] boolean | semmle.label | [KeywordTypeExpr] boolean | -| type_alias.ts:13:7:13:10 | [KeywordTypeExpr] null | semmle.label | [KeywordTypeExpr] null | -| type_alias.ts:14:7:14:34 | [InterfaceTypeExpr] { [prop ... Json } | semmle.label | [InterfaceTypeExpr] { [prop ... Json } | -| type_alias.ts:14:9:14:32 | [FunctionExpr] [proper ... ]: Json | semmle.label | [FunctionExpr] [proper ... ]: Json | -| type_alias.ts:14:9:14:32 | [IndexSignature] [proper ... ]: Json | semmle.label | [IndexSignature] [proper ... ]: Json | -| type_alias.ts:14:10:14:17 | [SimpleParameter] property | semmle.label | [SimpleParameter] property | -| type_alias.ts:14:20:14:25 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| type_alias.ts:14:29:14:32 | [LocalTypeAccess] Json | semmle.label | [LocalTypeAccess] Json | -| type_alias.ts:15:7:15:10 | [LocalTypeAccess] Json | semmle.label | [LocalTypeAccess] Json | -| type_alias.ts:15:7:15:12 | [ArrayTypeExpr] Json[] | semmle.label | [ArrayTypeExpr] Json[] | -| type_alias.ts:17:1:17:15 | [DeclStmt] var json = ... | semmle.label | [DeclStmt] var json = ... | -| type_alias.ts:17:1:17:15 | [DeclStmt] var json = ... | semmle.order | 104 | -| type_alias.ts:17:5:17:8 | [VarDecl] json | semmle.label | [VarDecl] json | -| type_alias.ts:17:5:17:14 | [VariableDeclarator] json: Json | semmle.label | [VariableDeclarator] json: Json | -| type_alias.ts:17:11:17:14 | [LocalTypeAccess] Json | semmle.label | [LocalTypeAccess] Json | -| type_alias.ts:19:1:21:57 | [TypeAliasDeclaration,TypeDefinition] type Vi ... ode[]]; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Vi ... ode[]]; | -| type_alias.ts:19:1:21:57 | [TypeAliasDeclaration,TypeDefinition] type Vi ... ode[]]; | semmle.order | 105 | -| type_alias.ts:19:6:19:16 | [Identifier] VirtualNode | semmle.label | [Identifier] VirtualNode | -| type_alias.ts:20:5:21:56 | [UnionTypeExpr] \| strin ... Node[]] | semmle.label | [UnionTypeExpr] \| strin ... Node[]] | -| type_alias.ts:20:7:20:12 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| type_alias.ts:21:7:21:56 | [TupleTypeExpr] [string ... Node[]] | semmle.label | [TupleTypeExpr] [string ... Node[]] | -| type_alias.ts:21:8:21:13 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| type_alias.ts:21:16:21:37 | [InterfaceTypeExpr] { [key: ... : any } | semmle.label | [InterfaceTypeExpr] { [key: ... : any } | -| type_alias.ts:21:18:21:35 | [FunctionExpr] [key: string]: any | semmle.label | [FunctionExpr] [key: string]: any | -| type_alias.ts:21:18:21:35 | [IndexSignature] [key: string]: any | semmle.label | [IndexSignature] [key: string]: any | -| type_alias.ts:21:19:21:21 | [SimpleParameter] key | semmle.label | [SimpleParameter] key | -| type_alias.ts:21:24:21:29 | [KeywordTypeExpr] string | semmle.label | [KeywordTypeExpr] string | -| type_alias.ts:21:33:21:35 | [KeywordTypeExpr] any | semmle.label | [KeywordTypeExpr] any | -| type_alias.ts:21:40:21:55 | [RestTypeExpr] ...VirtualNode[] | semmle.label | [RestTypeExpr] ...VirtualNode[] | -| type_alias.ts:21:43:21:53 | [LocalTypeAccess] VirtualNode | semmle.label | [LocalTypeAccess] VirtualNode | -| type_alias.ts:21:43:21:55 | [ArrayTypeExpr] VirtualNode[] | semmle.label | [ArrayTypeExpr] VirtualNode[] | -| type_alias.ts:23:1:27:6 | [DeclStmt] const myNode = ... | semmle.label | [DeclStmt] const myNode = ... | -| type_alias.ts:23:1:27:6 | [DeclStmt] const myNode = ... | semmle.order | 106 | -| type_alias.ts:23:7:23:12 | [VarDecl] myNode | semmle.label | [VarDecl] myNode | -| type_alias.ts:23:7:27:5 | [VariableDeclarator] myNode: ... ] ] | semmle.label | [VariableDeclarator] myNode: ... ] ] | -| type_alias.ts:23:15:23:25 | [LocalTypeAccess] VirtualNode | semmle.label | [LocalTypeAccess] VirtualNode | -| type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | semmle.label | [ArrayExpr] ["div", ... ] ] | -| type_alias.ts:24:6:24:10 | [Literal] "div" | semmle.label | [Literal] "div" | -| type_alias.ts:24:13:24:28 | [ObjectExpr] {id: ...} | semmle.label | [ObjectExpr] {id: ...} | -| type_alias.ts:24:15:24:16 | [Label] id | semmle.label | [Label] id | -| type_alias.ts:24:15:24:26 | [Property] id: "parent" | semmle.label | [Property] id: "parent" | -| type_alias.ts:24:19:24:26 | [Literal] "parent" | semmle.label | [Literal] "parent" | -| type_alias.ts:25:9:25:61 | [ArrayExpr] ["div", ... child"] | semmle.label | [ArrayExpr] ["div", ... child"] | -| type_alias.ts:25:10:25:14 | [Literal] "div" | semmle.label | [Literal] "div" | -| type_alias.ts:25:17:25:37 | [ObjectExpr] {id: ...} | semmle.label | [ObjectExpr] {id: ...} | -| type_alias.ts:25:19:25:20 | [Label] id | semmle.label | [Label] id | -| type_alias.ts:25:19:25:35 | [Property] id: "first-child" | semmle.label | [Property] id: "first-child" | -| type_alias.ts:25:23:25:35 | [Literal] "first-child" | semmle.label | [Literal] "first-child" | -| type_alias.ts:25:40:25:60 | [Literal] "I'm the first child" | semmle.label | [Literal] "I'm the first child" | -| type_alias.ts:26:9:26:63 | [ArrayExpr] ["div", ... child"] | semmle.label | [ArrayExpr] ["div", ... child"] | -| type_alias.ts:26:10:26:14 | [Literal] "div" | semmle.label | [Literal] "div" | -| type_alias.ts:26:17:26:38 | [ObjectExpr] {id: ...} | semmle.label | [ObjectExpr] {id: ...} | -| type_alias.ts:26:19:26:20 | [Label] id | semmle.label | [Label] id | -| type_alias.ts:26:19:26:36 | [Property] id: "second-child" | semmle.label | [Property] id: "second-child" | -| type_alias.ts:26:23:26:36 | [Literal] "second-child" | semmle.label | [Literal] "second-child" | -| type_alias.ts:26:41:26:62 | [Literal] "I'm the second child" | semmle.label | [Literal] "I'm the second child" | -| type_definition_objects.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | semmle.label | [ImportDeclaration] import ... dummy"; | -| type_definition_objects.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | semmle.order | 107 | -| type_definition_objects.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.label | [ImportSpecifier] * as dummy | -| type_definition_objects.ts:1:13:1:17 | [VarDecl] dummy | semmle.label | [VarDecl] dummy | -| type_definition_objects.ts:1:24:1:32 | [Literal] "./dummy" | semmle.label | [Literal] "./dummy" | -| type_definition_objects.ts:3:1:3:17 | [ExportDeclaration] export class C {} | semmle.label | [ExportDeclaration] export class C {} | -| type_definition_objects.ts:3:1:3:17 | [ExportDeclaration] export class C {} | semmle.order | 108 | -| type_definition_objects.ts:3:8:3:17 | [ClassDefinition,TypeDefinition] class C {} | semmle.label | [ClassDefinition,TypeDefinition] class C {} | -| type_definition_objects.ts:3:14:3:14 | [VarDecl] C | semmle.label | [VarDecl] C | -| type_definition_objects.ts:3:16:3:15 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| type_definition_objects.ts:3:16:3:15 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | [ClassInitializedMember,ConstructorDefinition] constructor() {} | -| type_definition_objects.ts:3:16:3:15 | [FunctionExpr] () {} | semmle.label | [FunctionExpr] () {} | -| type_definition_objects.ts:3:16:3:15 | [Label] constructor | semmle.label | [Label] constructor | -| type_definition_objects.ts:4:1:4:17 | [DeclStmt] let classObj = ... | semmle.label | [DeclStmt] let classObj = ... | -| type_definition_objects.ts:4:1:4:17 | [DeclStmt] let classObj = ... | semmle.order | 109 | -| type_definition_objects.ts:4:5:4:12 | [VarDecl] classObj | semmle.label | [VarDecl] classObj | -| type_definition_objects.ts:4:5:4:16 | [VariableDeclarator] classObj = C | semmle.label | [VariableDeclarator] classObj = C | -| type_definition_objects.ts:4:16:4:16 | [VarRef] C | semmle.label | [VarRef] C | -| type_definition_objects.ts:6:1:6:16 | [ExportDeclaration] export enum E {} | semmle.label | [ExportDeclaration] export enum E {} | -| type_definition_objects.ts:6:1:6:16 | [ExportDeclaration] export enum E {} | semmle.order | 110 | -| type_definition_objects.ts:6:8:6:16 | [EnumDeclaration,TypeDefinition] enum E {} | semmle.label | [EnumDeclaration,TypeDefinition] enum E {} | -| type_definition_objects.ts:6:13:6:13 | [VarDecl] E | semmle.label | [VarDecl] E | -| type_definition_objects.ts:7:1:7:16 | [DeclStmt] let enumObj = ... | semmle.label | [DeclStmt] let enumObj = ... | -| type_definition_objects.ts:7:1:7:16 | [DeclStmt] let enumObj = ... | semmle.order | 111 | -| type_definition_objects.ts:7:5:7:11 | [VarDecl] enumObj | semmle.label | [VarDecl] enumObj | -| type_definition_objects.ts:7:5:7:15 | [VariableDeclarator] enumObj = E | semmle.label | [VariableDeclarator] enumObj = E | -| type_definition_objects.ts:7:15:7:15 | [VarRef] E | semmle.label | [VarRef] E | -| type_definition_objects.ts:9:1:9:22 | [ExportDeclaration] export ... e N {;} | semmle.label | [ExportDeclaration] export ... e N {;} | -| type_definition_objects.ts:9:1:9:22 | [ExportDeclaration] export ... e N {;} | semmle.order | 112 | -| type_definition_objects.ts:9:8:9:22 | [NamespaceDeclaration] namespace N {;} | semmle.label | [NamespaceDeclaration] namespace N {;} | -| type_definition_objects.ts:9:18:9:18 | [VarDecl] N | semmle.label | [VarDecl] N | -| type_definition_objects.ts:9:21:9:21 | [EmptyStmt] ; | semmle.label | [EmptyStmt] ; | -| type_definition_objects.ts:10:1:10:21 | [DeclStmt] let namespaceObj = ... | semmle.label | [DeclStmt] let namespaceObj = ... | -| type_definition_objects.ts:10:1:10:21 | [DeclStmt] let namespaceObj = ... | semmle.order | 113 | -| type_definition_objects.ts:10:5:10:16 | [VarDecl] namespaceObj | semmle.label | [VarDecl] namespaceObj | -| type_definition_objects.ts:10:5:10:20 | [VariableDeclarator] namespaceObj = N | semmle.label | [VariableDeclarator] namespaceObj = N | -| type_definition_objects.ts:10:20:10:20 | [VarRef] N | semmle.label | [VarRef] N | -| type_definitions.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | semmle.label | [ImportDeclaration] import ... dummy"; | -| type_definitions.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | semmle.order | 114 | -| type_definitions.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.label | [ImportSpecifier] * as dummy | -| type_definitions.ts:1:13:1:17 | [VarDecl] dummy | semmle.label | [VarDecl] dummy | -| type_definitions.ts:1:24:1:32 | [Literal] "./dummy" | semmle.label | [Literal] "./dummy" | -| type_definitions.ts:3:1:5:1 | [InterfaceDeclaration,TypeDefinition] interfa ... x: S; } | semmle.label | [InterfaceDeclaration,TypeDefinition] interfa ... x: S; } | -| type_definitions.ts:3:1:5:1 | [InterfaceDeclaration,TypeDefinition] interfa ... x: S; } | semmle.order | 115 | -| type_definitions.ts:3:11:3:11 | [Identifier] I | semmle.label | [Identifier] I | -| type_definitions.ts:3:13:3:13 | [Identifier] S | semmle.label | [Identifier] S | -| type_definitions.ts:3:13:3:13 | [TypeParameter] S | semmle.label | [TypeParameter] S | -| type_definitions.ts:4:3:4:3 | [Label] x | semmle.label | [Label] x | -| type_definitions.ts:4:3:4:7 | [FieldDeclaration] x: S; | semmle.label | [FieldDeclaration] x: S; | -| type_definitions.ts:4:6:4:6 | [LocalTypeAccess] S | semmle.label | [LocalTypeAccess] S | -| type_definitions.ts:6:1:6:16 | [DeclStmt] let i = ... | semmle.label | [DeclStmt] let i = ... | -| type_definitions.ts:6:1:6:16 | [DeclStmt] let i = ... | semmle.order | 116 | -| type_definitions.ts:6:5:6:5 | [VarDecl] i | semmle.label | [VarDecl] i | -| type_definitions.ts:6:5:6:16 | [VariableDeclarator] i: I | semmle.label | [VariableDeclarator] i: I | -| type_definitions.ts:6:8:6:8 | [LocalTypeAccess] I | semmle.label | [LocalTypeAccess] I | -| type_definitions.ts:6:8:6:16 | [GenericTypeExpr] I | semmle.label | [GenericTypeExpr] I | -| type_definitions.ts:6:10:6:15 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | semmle.label | [ClassDefinition,TypeDefinition] class C ... x: T } | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | semmle.order | 117 | -| type_definitions.ts:8:7:8:7 | [VarDecl] C | semmle.label | [VarDecl] C | -| type_definitions.ts:8:8:8:7 | [BlockStmt] {} | semmle.label | [BlockStmt] {} | -| type_definitions.ts:8:8:8:7 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | [ClassInitializedMember,ConstructorDefinition] constructor() {} | -| type_definitions.ts:8:8:8:7 | [FunctionExpr] () {} | semmle.label | [FunctionExpr] () {} | -| type_definitions.ts:8:8:8:7 | [Label] constructor | semmle.label | [Label] constructor | -| type_definitions.ts:8:9:8:9 | [Identifier] T | semmle.label | [Identifier] T | -| type_definitions.ts:8:9:8:9 | [TypeParameter] T | semmle.label | [TypeParameter] T | -| type_definitions.ts:9:3:9:3 | [Label] x | semmle.label | [Label] x | -| type_definitions.ts:9:3:9:6 | [FieldDeclaration] x: T | semmle.label | [FieldDeclaration] x: T | -| type_definitions.ts:9:6:9:6 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| type_definitions.ts:11:1:11:17 | [DeclStmt] let c = ... | semmle.label | [DeclStmt] let c = ... | -| type_definitions.ts:11:1:11:17 | [DeclStmt] let c = ... | semmle.order | 118 | -| type_definitions.ts:11:5:11:5 | [VarDecl] c | semmle.label | [VarDecl] c | -| type_definitions.ts:11:5:11:16 | [VariableDeclarator] c: C | semmle.label | [VariableDeclarator] c: C | -| type_definitions.ts:11:8:11:8 | [LocalTypeAccess] C | semmle.label | [LocalTypeAccess] C | -| type_definitions.ts:11:8:11:16 | [GenericTypeExpr] C | semmle.label | [GenericTypeExpr] C | -| type_definitions.ts:11:10:11:15 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | semmle.label | [EnumDeclaration,TypeDefinition] enum Co ... blue } | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | semmle.order | 119 | -| type_definitions.ts:13:6:13:10 | [VarDecl] Color | semmle.label | [VarDecl] Color | -| type_definitions.ts:14:3:14:5 | [EnumMember,TypeDefinition] red | semmle.label | [EnumMember,TypeDefinition] red | -| type_definitions.ts:14:3:14:5 | [VarDecl] red | semmle.label | [VarDecl] red | -| type_definitions.ts:14:8:14:12 | [EnumMember,TypeDefinition] green | semmle.label | [EnumMember,TypeDefinition] green | -| type_definitions.ts:14:8:14:12 | [VarDecl] green | semmle.label | [VarDecl] green | -| type_definitions.ts:14:15:14:18 | [EnumMember,TypeDefinition] blue | semmle.label | [EnumMember,TypeDefinition] blue | -| type_definitions.ts:14:15:14:18 | [VarDecl] blue | semmle.label | [VarDecl] blue | -| type_definitions.ts:16:1:16:17 | [DeclStmt] let color = ... | semmle.label | [DeclStmt] let color = ... | -| type_definitions.ts:16:1:16:17 | [DeclStmt] let color = ... | semmle.order | 120 | -| type_definitions.ts:16:5:16:9 | [VarDecl] color | semmle.label | [VarDecl] color | -| type_definitions.ts:16:5:16:16 | [VariableDeclarator] color: Color | semmle.label | [VariableDeclarator] color: Color | -| type_definitions.ts:16:12:16:16 | [LocalTypeAccess] Color | semmle.label | [LocalTypeAccess] Color | -| type_definitions.ts:18:1:18:33 | [EnumDeclaration,TypeDefinition] enum En ... ember } | semmle.label | [EnumDeclaration,TypeDefinition] enum En ... ember } | -| type_definitions.ts:18:1:18:33 | [EnumDeclaration,TypeDefinition] enum En ... ember } | semmle.order | 121 | -| type_definitions.ts:18:6:18:22 | [VarDecl] EnumWithOneMember | semmle.label | [VarDecl] EnumWithOneMember | -| type_definitions.ts:18:26:18:31 | [EnumMember,TypeDefinition] member | semmle.label | [EnumMember,TypeDefinition] member | -| type_definitions.ts:18:26:18:31 | [VarDecl] member | semmle.label | [VarDecl] member | -| type_definitions.ts:19:1:19:25 | [DeclStmt] let e = ... | semmle.label | [DeclStmt] let e = ... | -| type_definitions.ts:19:1:19:25 | [DeclStmt] let e = ... | semmle.order | 122 | -| type_definitions.ts:19:5:19:5 | [VarDecl] e | semmle.label | [VarDecl] e | -| type_definitions.ts:19:5:19:24 | [VariableDeclarator] e: EnumWithOneMember | semmle.label | [VariableDeclarator] e: EnumWithOneMember | -| type_definitions.ts:19:8:19:24 | [LocalTypeAccess] EnumWithOneMember | semmle.label | [LocalTypeAccess] EnumWithOneMember | -| type_definitions.ts:21:1:21:20 | [TypeAliasDeclaration,TypeDefinition] type Alias = T[]; | semmle.label | [TypeAliasDeclaration,TypeDefinition] type Alias = T[]; | -| type_definitions.ts:21:1:21:20 | [TypeAliasDeclaration,TypeDefinition] type Alias = T[]; | semmle.order | 123 | -| type_definitions.ts:21:6:21:10 | [Identifier] Alias | semmle.label | [Identifier] Alias | -| type_definitions.ts:21:12:21:12 | [Identifier] T | semmle.label | [Identifier] T | -| type_definitions.ts:21:12:21:12 | [TypeParameter] T | semmle.label | [TypeParameter] T | -| type_definitions.ts:21:17:21:17 | [LocalTypeAccess] T | semmle.label | [LocalTypeAccess] T | -| type_definitions.ts:21:17:21:19 | [ArrayTypeExpr] T[] | semmle.label | [ArrayTypeExpr] T[] | -| type_definitions.ts:22:1:22:39 | [DeclStmt] let aliasForNumberArray = ... | semmle.label | [DeclStmt] let aliasForNumberArray = ... | -| type_definitions.ts:22:1:22:39 | [DeclStmt] let aliasForNumberArray = ... | semmle.order | 124 | -| type_definitions.ts:22:5:22:23 | [VarDecl] aliasForNumberArray | semmle.label | [VarDecl] aliasForNumberArray | -| type_definitions.ts:22:5:22:38 | [VariableDeclarator] aliasFo ... number> | semmle.label | [VariableDeclarator] aliasFo ... number> | -| type_definitions.ts:22:26:22:30 | [LocalTypeAccess] Alias | semmle.label | [LocalTypeAccess] Alias | -| type_definitions.ts:22:26:22:38 | [GenericTypeExpr] Alias | semmle.label | [GenericTypeExpr] Alias | -| type_definitions.ts:22:32:22:37 | [KeywordTypeExpr] number | semmle.label | [KeywordTypeExpr] number | -edges -| badTypes.ts:5:1:5:29 | [InterfaceDeclaration,TypeDefinition] interfa ... is.B {} | badTypes.ts:5:11:5:11 | [Identifier] A | semmle.label | 1 | -| badTypes.ts:5:1:5:29 | [InterfaceDeclaration,TypeDefinition] interfa ... is.B {} | badTypes.ts:5:11:5:11 | [Identifier] A | semmle.order | 1 | -| badTypes.ts:6:1:6:24 | [TypeAliasDeclaration,TypeDefinition] type T ... ar.bar; | badTypes.ts:6:6:6:6 | [Identifier] T | semmle.label | 1 | -| badTypes.ts:6:1:6:24 | [TypeAliasDeclaration,TypeDefinition] type T ... ar.bar; | badTypes.ts:6:6:6:6 | [Identifier] T | semmle.order | 1 | -| badTypes.ts:6:1:6:24 | [TypeAliasDeclaration,TypeDefinition] type T ... ar.bar; | badTypes.ts:6:10:6:23 | [TypeofTypeExpr] typeof var.bar | semmle.label | 2 | -| badTypes.ts:6:1:6:24 | [TypeAliasDeclaration,TypeDefinition] type T ... ar.bar; | badTypes.ts:6:10:6:23 | [TypeofTypeExpr] typeof var.bar | semmle.order | 2 | -| badTypes.ts:6:10:6:23 | [TypeofTypeExpr] typeof var.bar | badTypes.ts:6:17:6:23 | [VarTypeAccess] var.bar | semmle.label | 1 | -| badTypes.ts:6:10:6:23 | [TypeofTypeExpr] typeof var.bar | badTypes.ts:6:17:6:23 | [VarTypeAccess] var.bar | semmle.order | 1 | -| badTypes.ts:6:17:6:23 | [VarTypeAccess] var.bar | badTypes.ts:6:17:6:19 | [LocalVarTypeAccess] var | semmle.label | 1 | -| badTypes.ts:6:17:6:23 | [VarTypeAccess] var.bar | badTypes.ts:6:17:6:19 | [LocalVarTypeAccess] var | semmle.order | 1 | -| badTypes.ts:6:17:6:23 | [VarTypeAccess] var.bar | badTypes.ts:6:21:6:23 | [Identifier] bar | semmle.label | 2 | -| badTypes.ts:6:17:6:23 | [VarTypeAccess] var.bar | badTypes.ts:6:21:6:23 | [Identifier] bar | semmle.order | 2 | -| boolean-type.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | boolean-type.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.label | 1 | -| boolean-type.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | boolean-type.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.order | 1 | -| boolean-type.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | boolean-type.ts:1:24:1:32 | [Literal] "./dummy" | semmle.label | 2 | -| boolean-type.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | boolean-type.ts:1:24:1:32 | [Literal] "./dummy" | semmle.order | 2 | -| boolean-type.ts:1:8:1:17 | [ImportSpecifier] * as dummy | boolean-type.ts:1:13:1:17 | [VarDecl] dummy | semmle.label | 1 | -| boolean-type.ts:1:8:1:17 | [ImportSpecifier] * as dummy | boolean-type.ts:1:13:1:17 | [VarDecl] dummy | semmle.order | 1 | -| boolean-type.ts:3:1:3:16 | [DeclStmt] var true1 = ... | boolean-type.ts:3:5:3:15 | [VariableDeclarator] true1: true | semmle.label | 1 | -| boolean-type.ts:3:1:3:16 | [DeclStmt] var true1 = ... | boolean-type.ts:3:5:3:15 | [VariableDeclarator] true1: true | semmle.order | 1 | -| boolean-type.ts:3:5:3:15 | [VariableDeclarator] true1: true | boolean-type.ts:3:5:3:9 | [VarDecl] true1 | semmle.label | 1 | -| boolean-type.ts:3:5:3:15 | [VariableDeclarator] true1: true | boolean-type.ts:3:5:3:9 | [VarDecl] true1 | semmle.order | 1 | -| boolean-type.ts:3:5:3:15 | [VariableDeclarator] true1: true | boolean-type.ts:3:12:3:15 | [LiteralTypeExpr] true | semmle.label | 2 | -| boolean-type.ts:3:5:3:15 | [VariableDeclarator] true1: true | boolean-type.ts:3:12:3:15 | [LiteralTypeExpr] true | semmle.order | 2 | -| boolean-type.ts:4:1:4:23 | [DeclStmt] var true2 = ... | boolean-type.ts:4:5:4:22 | [VariableDeclarator] true2: true \| true | semmle.label | 1 | -| boolean-type.ts:4:1:4:23 | [DeclStmt] var true2 = ... | boolean-type.ts:4:5:4:22 | [VariableDeclarator] true2: true \| true | semmle.order | 1 | -| boolean-type.ts:4:5:4:22 | [VariableDeclarator] true2: true \| true | boolean-type.ts:4:5:4:9 | [VarDecl] true2 | semmle.label | 1 | -| boolean-type.ts:4:5:4:22 | [VariableDeclarator] true2: true \| true | boolean-type.ts:4:5:4:9 | [VarDecl] true2 | semmle.order | 1 | -| boolean-type.ts:4:5:4:22 | [VariableDeclarator] true2: true \| true | boolean-type.ts:4:12:4:22 | [UnionTypeExpr] true \| true | semmle.label | 2 | -| boolean-type.ts:4:5:4:22 | [VariableDeclarator] true2: true \| true | boolean-type.ts:4:12:4:22 | [UnionTypeExpr] true \| true | semmle.order | 2 | -| boolean-type.ts:4:12:4:22 | [UnionTypeExpr] true \| true | boolean-type.ts:4:12:4:15 | [LiteralTypeExpr] true | semmle.label | 1 | -| boolean-type.ts:4:12:4:22 | [UnionTypeExpr] true \| true | boolean-type.ts:4:12:4:15 | [LiteralTypeExpr] true | semmle.order | 1 | -| boolean-type.ts:4:12:4:22 | [UnionTypeExpr] true \| true | boolean-type.ts:4:19:4:22 | [LiteralTypeExpr] true | semmle.label | 2 | -| boolean-type.ts:4:12:4:22 | [UnionTypeExpr] true \| true | boolean-type.ts:4:19:4:22 | [LiteralTypeExpr] true | semmle.order | 2 | -| boolean-type.ts:6:1:6:18 | [DeclStmt] var false1 = ... | boolean-type.ts:6:5:6:17 | [VariableDeclarator] false1: false | semmle.label | 1 | -| boolean-type.ts:6:1:6:18 | [DeclStmt] var false1 = ... | boolean-type.ts:6:5:6:17 | [VariableDeclarator] false1: false | semmle.order | 1 | -| boolean-type.ts:6:5:6:17 | [VariableDeclarator] false1: false | boolean-type.ts:6:5:6:10 | [VarDecl] false1 | semmle.label | 1 | -| boolean-type.ts:6:5:6:17 | [VariableDeclarator] false1: false | boolean-type.ts:6:5:6:10 | [VarDecl] false1 | semmle.order | 1 | -| boolean-type.ts:6:5:6:17 | [VariableDeclarator] false1: false | boolean-type.ts:6:13:6:17 | [LiteralTypeExpr] false | semmle.label | 2 | -| boolean-type.ts:6:5:6:17 | [VariableDeclarator] false1: false | boolean-type.ts:6:13:6:17 | [LiteralTypeExpr] false | semmle.order | 2 | -| boolean-type.ts:7:1:7:26 | [DeclStmt] var false2 = ... | boolean-type.ts:7:5:7:25 | [VariableDeclarator] false2: ... \| false | semmle.label | 1 | -| boolean-type.ts:7:1:7:26 | [DeclStmt] var false2 = ... | boolean-type.ts:7:5:7:25 | [VariableDeclarator] false2: ... \| false | semmle.order | 1 | -| boolean-type.ts:7:5:7:25 | [VariableDeclarator] false2: ... \| false | boolean-type.ts:7:5:7:10 | [VarDecl] false2 | semmle.label | 1 | -| boolean-type.ts:7:5:7:25 | [VariableDeclarator] false2: ... \| false | boolean-type.ts:7:5:7:10 | [VarDecl] false2 | semmle.order | 1 | -| boolean-type.ts:7:5:7:25 | [VariableDeclarator] false2: ... \| false | boolean-type.ts:7:13:7:25 | [UnionTypeExpr] false \| false | semmle.label | 2 | -| boolean-type.ts:7:5:7:25 | [VariableDeclarator] false2: ... \| false | boolean-type.ts:7:13:7:25 | [UnionTypeExpr] false \| false | semmle.order | 2 | -| boolean-type.ts:7:13:7:25 | [UnionTypeExpr] false \| false | boolean-type.ts:7:13:7:17 | [LiteralTypeExpr] false | semmle.label | 1 | -| boolean-type.ts:7:13:7:25 | [UnionTypeExpr] false \| false | boolean-type.ts:7:13:7:17 | [LiteralTypeExpr] false | semmle.order | 1 | -| boolean-type.ts:7:13:7:25 | [UnionTypeExpr] false \| false | boolean-type.ts:7:21:7:25 | [LiteralTypeExpr] false | semmle.label | 2 | -| boolean-type.ts:7:13:7:25 | [UnionTypeExpr] false \| false | boolean-type.ts:7:21:7:25 | [LiteralTypeExpr] false | semmle.order | 2 | -| boolean-type.ts:9:1:9:22 | [DeclStmt] var boolean1 = ... | boolean-type.ts:9:5:9:21 | [VariableDeclarator] boolean1: boolean | semmle.label | 1 | -| boolean-type.ts:9:1:9:22 | [DeclStmt] var boolean1 = ... | boolean-type.ts:9:5:9:21 | [VariableDeclarator] boolean1: boolean | semmle.order | 1 | -| boolean-type.ts:9:5:9:21 | [VariableDeclarator] boolean1: boolean | boolean-type.ts:9:5:9:12 | [VarDecl] boolean1 | semmle.label | 1 | -| boolean-type.ts:9:5:9:21 | [VariableDeclarator] boolean1: boolean | boolean-type.ts:9:5:9:12 | [VarDecl] boolean1 | semmle.order | 1 | -| boolean-type.ts:9:5:9:21 | [VariableDeclarator] boolean1: boolean | boolean-type.ts:9:15:9:21 | [KeywordTypeExpr] boolean | semmle.label | 2 | -| boolean-type.ts:9:5:9:21 | [VariableDeclarator] boolean1: boolean | boolean-type.ts:9:15:9:21 | [KeywordTypeExpr] boolean | semmle.order | 2 | -| boolean-type.ts:10:1:10:27 | [DeclStmt] var boolean2 = ... | boolean-type.ts:10:5:10:26 | [VariableDeclarator] boolean ... \| false | semmle.label | 1 | -| boolean-type.ts:10:1:10:27 | [DeclStmt] var boolean2 = ... | boolean-type.ts:10:5:10:26 | [VariableDeclarator] boolean ... \| false | semmle.order | 1 | -| boolean-type.ts:10:5:10:26 | [VariableDeclarator] boolean ... \| false | boolean-type.ts:10:5:10:12 | [VarDecl] boolean2 | semmle.label | 1 | -| boolean-type.ts:10:5:10:26 | [VariableDeclarator] boolean ... \| false | boolean-type.ts:10:5:10:12 | [VarDecl] boolean2 | semmle.order | 1 | -| boolean-type.ts:10:5:10:26 | [VariableDeclarator] boolean ... \| false | boolean-type.ts:10:15:10:26 | [UnionTypeExpr] true \| false | semmle.label | 2 | -| boolean-type.ts:10:5:10:26 | [VariableDeclarator] boolean ... \| false | boolean-type.ts:10:15:10:26 | [UnionTypeExpr] true \| false | semmle.order | 2 | -| boolean-type.ts:10:15:10:26 | [UnionTypeExpr] true \| false | boolean-type.ts:10:15:10:18 | [LiteralTypeExpr] true | semmle.label | 1 | -| boolean-type.ts:10:15:10:26 | [UnionTypeExpr] true \| false | boolean-type.ts:10:15:10:18 | [LiteralTypeExpr] true | semmle.order | 1 | -| boolean-type.ts:10:15:10:26 | [UnionTypeExpr] true \| false | boolean-type.ts:10:22:10:26 | [LiteralTypeExpr] false | semmle.label | 2 | -| boolean-type.ts:10:15:10:26 | [UnionTypeExpr] true \| false | boolean-type.ts:10:22:10:26 | [LiteralTypeExpr] false | semmle.order | 2 | -| boolean-type.ts:11:1:11:27 | [DeclStmt] var boolean3 = ... | boolean-type.ts:11:5:11:26 | [VariableDeclarator] boolean ... \| true | semmle.label | 1 | -| boolean-type.ts:11:1:11:27 | [DeclStmt] var boolean3 = ... | boolean-type.ts:11:5:11:26 | [VariableDeclarator] boolean ... \| true | semmle.order | 1 | -| boolean-type.ts:11:5:11:26 | [VariableDeclarator] boolean ... \| true | boolean-type.ts:11:5:11:12 | [VarDecl] boolean3 | semmle.label | 1 | -| boolean-type.ts:11:5:11:26 | [VariableDeclarator] boolean ... \| true | boolean-type.ts:11:5:11:12 | [VarDecl] boolean3 | semmle.order | 1 | -| boolean-type.ts:11:5:11:26 | [VariableDeclarator] boolean ... \| true | boolean-type.ts:11:15:11:26 | [UnionTypeExpr] false \| true | semmle.label | 2 | -| boolean-type.ts:11:5:11:26 | [VariableDeclarator] boolean ... \| true | boolean-type.ts:11:15:11:26 | [UnionTypeExpr] false \| true | semmle.order | 2 | -| boolean-type.ts:11:15:11:26 | [UnionTypeExpr] false \| true | boolean-type.ts:11:15:11:19 | [LiteralTypeExpr] false | semmle.label | 1 | -| boolean-type.ts:11:15:11:26 | [UnionTypeExpr] false \| true | boolean-type.ts:11:15:11:19 | [LiteralTypeExpr] false | semmle.order | 1 | -| boolean-type.ts:11:15:11:26 | [UnionTypeExpr] false \| true | boolean-type.ts:11:23:11:26 | [LiteralTypeExpr] true | semmle.label | 2 | -| boolean-type.ts:11:15:11:26 | [UnionTypeExpr] false \| true | boolean-type.ts:11:23:11:26 | [LiteralTypeExpr] true | semmle.order | 2 | -| boolean-type.ts:13:1:13:32 | [DeclStmt] var boolean4 = ... | boolean-type.ts:13:5:13:31 | [VariableDeclarator] boolean ... boolean | semmle.label | 1 | -| boolean-type.ts:13:1:13:32 | [DeclStmt] var boolean4 = ... | boolean-type.ts:13:5:13:31 | [VariableDeclarator] boolean ... boolean | semmle.order | 1 | -| boolean-type.ts:13:5:13:31 | [VariableDeclarator] boolean ... boolean | boolean-type.ts:13:5:13:12 | [VarDecl] boolean4 | semmle.label | 1 | -| boolean-type.ts:13:5:13:31 | [VariableDeclarator] boolean ... boolean | boolean-type.ts:13:5:13:12 | [VarDecl] boolean4 | semmle.order | 1 | -| boolean-type.ts:13:5:13:31 | [VariableDeclarator] boolean ... boolean | boolean-type.ts:13:15:13:31 | [UnionTypeExpr] boolean \| boolean | semmle.label | 2 | -| boolean-type.ts:13:5:13:31 | [VariableDeclarator] boolean ... boolean | boolean-type.ts:13:15:13:31 | [UnionTypeExpr] boolean \| boolean | semmle.order | 2 | -| boolean-type.ts:13:15:13:31 | [UnionTypeExpr] boolean \| boolean | boolean-type.ts:13:15:13:21 | [KeywordTypeExpr] boolean | semmle.label | 1 | -| boolean-type.ts:13:15:13:31 | [UnionTypeExpr] boolean \| boolean | boolean-type.ts:13:15:13:21 | [KeywordTypeExpr] boolean | semmle.order | 1 | -| boolean-type.ts:13:15:13:31 | [UnionTypeExpr] boolean \| boolean | boolean-type.ts:13:25:13:31 | [KeywordTypeExpr] boolean | semmle.label | 2 | -| boolean-type.ts:13:15:13:31 | [UnionTypeExpr] boolean \| boolean | boolean-type.ts:13:25:13:31 | [KeywordTypeExpr] boolean | semmle.order | 2 | -| boolean-type.ts:14:1:14:29 | [DeclStmt] var boolean5 = ... | boolean-type.ts:14:5:14:28 | [VariableDeclarator] boolean ... \| true | semmle.label | 1 | -| boolean-type.ts:14:1:14:29 | [DeclStmt] var boolean5 = ... | boolean-type.ts:14:5:14:28 | [VariableDeclarator] boolean ... \| true | semmle.order | 1 | -| boolean-type.ts:14:5:14:28 | [VariableDeclarator] boolean ... \| true | boolean-type.ts:14:5:14:12 | [VarDecl] boolean5 | semmle.label | 1 | -| boolean-type.ts:14:5:14:28 | [VariableDeclarator] boolean ... \| true | boolean-type.ts:14:5:14:12 | [VarDecl] boolean5 | semmle.order | 1 | -| boolean-type.ts:14:5:14:28 | [VariableDeclarator] boolean ... \| true | boolean-type.ts:14:15:14:28 | [UnionTypeExpr] boolean \| true | semmle.label | 2 | -| boolean-type.ts:14:5:14:28 | [VariableDeclarator] boolean ... \| true | boolean-type.ts:14:15:14:28 | [UnionTypeExpr] boolean \| true | semmle.order | 2 | -| boolean-type.ts:14:15:14:28 | [UnionTypeExpr] boolean \| true | boolean-type.ts:14:15:14:21 | [KeywordTypeExpr] boolean | semmle.label | 1 | -| boolean-type.ts:14:15:14:28 | [UnionTypeExpr] boolean \| true | boolean-type.ts:14:15:14:21 | [KeywordTypeExpr] boolean | semmle.order | 1 | -| boolean-type.ts:14:15:14:28 | [UnionTypeExpr] boolean \| true | boolean-type.ts:14:25:14:28 | [LiteralTypeExpr] true | semmle.label | 2 | -| boolean-type.ts:14:15:14:28 | [UnionTypeExpr] boolean \| true | boolean-type.ts:14:25:14:28 | [LiteralTypeExpr] true | semmle.order | 2 | -| boolean-type.ts:15:1:15:30 | [DeclStmt] var boolean6 = ... | boolean-type.ts:15:5:15:29 | [VariableDeclarator] boolean ... boolean | semmle.label | 1 | -| boolean-type.ts:15:1:15:30 | [DeclStmt] var boolean6 = ... | boolean-type.ts:15:5:15:29 | [VariableDeclarator] boolean ... boolean | semmle.order | 1 | -| boolean-type.ts:15:5:15:29 | [VariableDeclarator] boolean ... boolean | boolean-type.ts:15:5:15:12 | [VarDecl] boolean6 | semmle.label | 1 | -| boolean-type.ts:15:5:15:29 | [VariableDeclarator] boolean ... boolean | boolean-type.ts:15:5:15:12 | [VarDecl] boolean6 | semmle.order | 1 | -| boolean-type.ts:15:5:15:29 | [VariableDeclarator] boolean ... boolean | boolean-type.ts:15:15:15:29 | [UnionTypeExpr] false \| boolean | semmle.label | 2 | -| boolean-type.ts:15:5:15:29 | [VariableDeclarator] boolean ... boolean | boolean-type.ts:15:15:15:29 | [UnionTypeExpr] false \| boolean | semmle.order | 2 | -| boolean-type.ts:15:15:15:29 | [UnionTypeExpr] false \| boolean | boolean-type.ts:15:15:15:19 | [LiteralTypeExpr] false | semmle.label | 1 | -| boolean-type.ts:15:15:15:29 | [UnionTypeExpr] false \| boolean | boolean-type.ts:15:15:15:19 | [LiteralTypeExpr] false | semmle.order | 1 | -| boolean-type.ts:15:15:15:29 | [UnionTypeExpr] false \| boolean | boolean-type.ts:15:23:15:29 | [KeywordTypeExpr] boolean | semmle.label | 2 | -| boolean-type.ts:15:15:15:29 | [UnionTypeExpr] false \| boolean | boolean-type.ts:15:23:15:29 | [KeywordTypeExpr] boolean | semmle.order | 2 | -| dummy.ts:2:1:2:17 | [ExportDeclaration] export let x = 5; | dummy.ts:2:8:2:17 | [DeclStmt] let x = ... | semmle.label | 1 | -| dummy.ts:2:1:2:17 | [ExportDeclaration] export let x = 5; | dummy.ts:2:8:2:17 | [DeclStmt] let x = ... | semmle.order | 1 | -| dummy.ts:2:8:2:17 | [DeclStmt] let x = ... | dummy.ts:2:12:2:16 | [VariableDeclarator] x = 5 | semmle.label | 1 | -| dummy.ts:2:8:2:17 | [DeclStmt] let x = ... | dummy.ts:2:12:2:16 | [VariableDeclarator] x = 5 | semmle.order | 1 | -| dummy.ts:2:12:2:16 | [VariableDeclarator] x = 5 | dummy.ts:2:12:2:12 | [VarDecl] x | semmle.label | 1 | -| dummy.ts:2:12:2:16 | [VariableDeclarator] x = 5 | dummy.ts:2:12:2:12 | [VarDecl] x | semmle.order | 1 | -| dummy.ts:2:12:2:16 | [VariableDeclarator] x = 5 | dummy.ts:2:16:2:16 | [Literal] 5 | semmle.label | 2 | -| dummy.ts:2:12:2:16 | [VariableDeclarator] x = 5 | dummy.ts:2:16:2:16 | [Literal] 5 | semmle.order | 2 | -| dummy.ts:4:1:4:24 | [ExportDeclaration] export ... /ab+c/; | dummy.ts:4:8:4:24 | [DeclStmt] let reg = ... | semmle.label | 1 | -| dummy.ts:4:1:4:24 | [ExportDeclaration] export ... /ab+c/; | dummy.ts:4:8:4:24 | [DeclStmt] let reg = ... | semmle.order | 1 | -| dummy.ts:4:8:4:24 | [DeclStmt] let reg = ... | dummy.ts:4:12:4:23 | [VariableDeclarator] reg = /ab+c/ | semmle.label | 1 | -| dummy.ts:4:8:4:24 | [DeclStmt] let reg = ... | dummy.ts:4:12:4:23 | [VariableDeclarator] reg = /ab+c/ | semmle.order | 1 | -| dummy.ts:4:12:4:23 | [VariableDeclarator] reg = /ab+c/ | dummy.ts:4:12:4:14 | [VarDecl] reg | semmle.label | 1 | -| dummy.ts:4:12:4:23 | [VariableDeclarator] reg = /ab+c/ | dummy.ts:4:12:4:14 | [VarDecl] reg | semmle.order | 1 | -| dummy.ts:4:12:4:23 | [VariableDeclarator] reg = /ab+c/ | dummy.ts:4:18:4:23 | [RegExpLiteral] /ab+c/ | semmle.label | 2 | -| dummy.ts:4:12:4:23 | [VariableDeclarator] reg = /ab+c/ | dummy.ts:4:18:4:23 | [RegExpLiteral] /ab+c/ | semmle.order | 2 | -| dummy.ts:4:18:4:23 | [RegExpLiteral] /ab+c/ | dummy.ts:4:19:4:22 | [RegExpSequence] ab+c | semmle.label | 0 | -| dummy.ts:4:18:4:23 | [RegExpLiteral] /ab+c/ | dummy.ts:4:19:4:22 | [RegExpSequence] ab+c | semmle.order | 0 | -| dummy.ts:4:19:4:22 | [RegExpSequence] ab+c | dummy.ts:4:19:4:19 | [RegExpNormalConstant] a | semmle.label | 0 | -| dummy.ts:4:19:4:22 | [RegExpSequence] ab+c | dummy.ts:4:19:4:19 | [RegExpNormalConstant] a | semmle.order | 0 | -| dummy.ts:4:19:4:22 | [RegExpSequence] ab+c | dummy.ts:4:20:4:21 | [RegExpPlus] b+ | semmle.label | 1 | -| dummy.ts:4:19:4:22 | [RegExpSequence] ab+c | dummy.ts:4:20:4:21 | [RegExpPlus] b+ | semmle.order | 1 | -| dummy.ts:4:19:4:22 | [RegExpSequence] ab+c | dummy.ts:4:22:4:22 | [RegExpNormalConstant] c | semmle.label | 2 | -| dummy.ts:4:19:4:22 | [RegExpSequence] ab+c | dummy.ts:4:22:4:22 | [RegExpNormalConstant] c | semmle.order | 2 | -| dummy.ts:4:20:4:21 | [RegExpPlus] b+ | dummy.ts:4:20:4:20 | [RegExpNormalConstant] b | semmle.label | 0 | -| dummy.ts:4:20:4:21 | [RegExpPlus] b+ | dummy.ts:4:20:4:20 | [RegExpNormalConstant] b | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:86:27:86:31 | [VarRef] value | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:86:27:86:31 | [VarRef] value | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:97:27:97:26 | [SpreadElement] ...args | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:97:27:97:26 | [SpreadElement] ...args | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:159:31:159:35 | [Literal] "red" | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:159:31:159:35 | [Literal] "red" | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:247:19:247:50 | [Literal] "Doing something before super()" | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:247:19:247:50 | [Literal] "Doing something before super()" | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:259:19:259:35 | [MethodCallExpr] payload.toFixed() | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:259:19:259:35 | [MethodCallExpr] payload.toFixed() | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:261:19:261:39 | [MethodCallExpr] payload ... rCase() | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:261:19:261:39 | [MethodCallExpr] payload ... rCase() | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:279:14:279:21 | [DotExpr] record.v | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:279:14:279:21 | [DotExpr] record.v | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:282:17:287:3 | [ObjectExpr] {kind: ...} | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:282:17:287:3 | [ObjectExpr] {kind: ...} | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:285:19:285:35 | [MethodCallExpr] val.toUpperCase() | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:285:19:285:35 | [MethodCallExpr] val.toUpperCase() | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:318:3:321:1 | [ObjectExpr] {produce: ...} | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:318:3:321:1 | [ObjectExpr] {produce: ...} | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:358:13:358:25 | [CallExpr] tstModuleES() | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:358:13:358:25 | [CallExpr] tstModuleES() | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:362:13:362:26 | [CallExpr] tstModuleCJS() | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:362:13:362:26 | [CallExpr] tstModuleCJS() | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:370:13:370:28 | [MethodCallExpr] A.resolvedFile() | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:370:13:370:28 | [MethodCallExpr] A.resolvedFile() | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:374:13:374:28 | [MethodCallExpr] B.resolvedFile() | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:374:13:374:28 | [MethodCallExpr] B.resolvedFile() | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:385:36:385:52 | [ArrayExpr] [42, true, "hi!"] | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:385:36:385:52 | [ArrayExpr] [42, true, "hi!"] | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:385:55:385:72 | [ArrayExpr] [0, false, "bye!"] | semmle.label | 1 | -| file://:0:0:0:0 | (Arguments) | tst.ts:385:55:385:72 | [ArrayExpr] [0, false, "bye!"] | semmle.order | 1 | -| file://:0:0:0:0 | (Arguments) | tst.ts:402:39:402:39 | [Literal] 0 | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:402:39:402:39 | [Literal] 0 | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:435:35:435:46 | [DotExpr] context.name | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:435:35:435:46 | [DotExpr] context.name | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:438:25:438:63 | [TemplateLiteral] `LOG: E ... ame}'.` | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:438:25:438:63 | [TemplateLiteral] `LOG: E ... ame}'.` | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:439:40:439:43 | [ThisExpr] this | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:439:40:439:43 | [ThisExpr] this | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:439:46:439:52 | [SpreadElement] ...args | semmle.label | 1 | -| file://:0:0:0:0 | (Arguments) | tst.ts:439:46:439:52 | [SpreadElement] ...args | semmle.order | 1 | -| file://:0:0:0:0 | (Arguments) | tst.ts:440:25:440:62 | [TemplateLiteral] `LOG: E ... ame}'.` | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:440:25:440:62 | [TemplateLiteral] `LOG: E ... ame}'.` | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:453:23:453:24 | [Literal] "" | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:453:23:453:24 | [Literal] "" | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:455:25:455:57 | [TemplateLiteral] `Hello, ... name}.` | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:455:25:455:57 | [TemplateLiteral] `Hello, ... name}.` | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:460:26:460:31 | [Literal] "John" | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:460:26:460:31 | [Literal] "John" | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:465:35:465:49 | [ArrayExpr] ["a", "b" ,"c"] | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:465:35:465:49 | [ArrayExpr] ["a", "b" ,"c"] | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:478:17:478:42 | [IndexExpr] SomeCla ... tadata] | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:478:17:478:42 | [IndexExpr] SomeCla ... tadata] | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:483:17:483:58 | [SatisfiesExpr] ["hello ... string> | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:483:17:483:58 | [SatisfiesExpr] ["hello ... string> | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:491:21:491:46 | [ArrayExpr] ["red", ... green"] | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:491:21:491:46 | [ArrayExpr] ["red", ... green"] | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:491:49:491:56 | [Literal] "yellow" | semmle.label | 1 | -| file://:0:0:0:0 | (Arguments) | tst.ts:491:49:491:56 | [Literal] "yellow" | semmle.order | 1 | -| file://:0:0:0:0 | (Arguments) | tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | semmle.order | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:493:52:495:3 | [ArrowFunctionExpr] (num, i ... d"; } | semmle.label | 1 | -| file://:0:0:0:0 | (Arguments) | tst.ts:493:52:495:3 | [ArrowFunctionExpr] (num, i ... d"; } | semmle.order | 1 | -| file://:0:0:0:0 | (Arguments) | tst.ts:500:13:500:38 | [ArrowFunctionExpr] s => ty ... string" | semmle.label | 0 | -| file://:0:0:0:0 | (Arguments) | tst.ts:500:13:500:38 | [ArrowFunctionExpr] s => ty ... string" | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:14:17:14:17 | [SimpleParameter] x | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:14:17:14:17 | [SimpleParameter] x | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:14:28:14:28 | [SimpleParameter] y | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:14:28:14:28 | [SimpleParameter] y | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:16:14:16:14 | [SimpleParameter] x | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:16:14:16:14 | [SimpleParameter] x | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:16:25:16:25 | [SimpleParameter] y | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:16:25:16:25 | [SimpleParameter] y | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:18:18:18:18 | [SimpleParameter] x | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:18:18:18:18 | [SimpleParameter] x | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:18:21:18:21 | [SimpleParameter] y | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:18:21:18:21 | [SimpleParameter] y | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:20:23:20:23 | [SimpleParameter] x | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:20:23:20:23 | [SimpleParameter] x | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:20:26:20:26 | [SimpleParameter] y | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:20:26:20:26 | [SimpleParameter] y | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:75:14:75:18 | [SimpleParameter] value | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:75:14:75:18 | [SimpleParameter] value | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:85:14:85:18 | [SimpleParameter] value | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:85:14:85:18 | [SimpleParameter] value | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:97:27:97:26 | [SimpleParameter] args | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:97:27:97:26 | [SimpleParameter] args | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:104:16:104:16 | [SimpleParameter] s | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:104:16:104:16 | [SimpleParameter] s | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:133:16:133:18 | [SimpleParameter] arg | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:133:16:133:18 | [SimpleParameter] arg | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:144:17:144:21 | [SimpleParameter] shape | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:144:17:144:21 | [SimpleParameter] shape | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:153:8:153:10 | [SimpleParameter] sym | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:153:8:153:10 | [SimpleParameter] sym | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:154:8:154:10 | [SimpleParameter] key | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:154:8:154:10 | [SimpleParameter] key | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:155:8:155:10 | [SimpleParameter] num | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:155:8:155:10 | [SimpleParameter] num | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:166:8:166:10 | [SimpleParameter] key | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:166:8:166:10 | [SimpleParameter] key | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:172:8:172:14 | [SimpleParameter] optName | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:172:8:172:14 | [SimpleParameter] optName | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:215:27:215:27 | [SimpleParameter] r | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:215:27:215:27 | [SimpleParameter] r | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:224:17:224:20 | [SimpleParameter] name | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:224:17:224:20 | [SimpleParameter] name | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:228:12:228:16 | [SimpleParameter] other | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:228:12:228:16 | [SimpleParameter] other | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:256:26:256:31 | [SimpleParameter] action | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:256:26:256:31 | [SimpleParameter] action | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:274:11:274:11 | [SimpleParameter] p | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:274:11:274:11 | [SimpleParameter] p | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:278:51:278:56 | [SimpleParameter] record | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:278:51:278:56 | [SimpleParameter] record | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:284:9:284:11 | [SimpleParameter] val | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:284:9:284:11 | [SimpleParameter] val | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:289:19:289:22 | [SimpleParameter] args | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:289:19:289:22 | [SimpleParameter] args | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:291:21:291:24 | [SimpleParameter] kind | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:291:21:291:24 | [SimpleParameter] kind | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:291:27:291:33 | [SimpleParameter] payload | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:291:27:291:33 | [SimpleParameter] payload | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:313:15:313:17 | [SimpleParameter] arg | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:313:15:313:17 | [SimpleParameter] arg | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:314:13:314:13 | [SimpleParameter] n | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:314:13:314:13 | [SimpleParameter] n | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:315:13:315:13 | [SimpleParameter] x | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:315:13:315:13 | [SimpleParameter] x | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:319:12:319:12 | [SimpleParameter] n | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:319:12:319:12 | [SimpleParameter] n | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:320:12:320:12 | [SimpleParameter] x | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:320:12:320:12 | [SimpleParameter] x | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:344:9:344:13 | [SimpleParameter] value | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:344:9:344:13 | [SimpleParameter] value | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:349:9:349:13 | [SimpleParameter] value | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:349:9:349:13 | [SimpleParameter] value | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:383:40:383:40 | [SimpleParameter] x | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:383:40:383:40 | [SimpleParameter] x | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:383:46:383:46 | [SimpleParameter] y | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:383:46:383:46 | [SimpleParameter] y | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:412:21:412:25 | [SimpleParameter] color | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:412:21:412:25 | [SimpleParameter] color | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:422:17:422:20 | [SimpleParameter] name | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:422:17:422:20 | [SimpleParameter] name | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:432:9:432:14 | [SimpleParameter] target | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:432:9:432:14 | [SimpleParameter] target | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:432:33:432:36 | [SimpleParameter] args | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:432:33:432:36 | [SimpleParameter] args | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:433:9:433:15 | [SimpleParameter] context | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:433:9:433:15 | [SimpleParameter] context | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:433:68:433:71 | [SimpleParameter] args | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:433:68:433:71 | [SimpleParameter] args | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:437:51:437:54 | [SimpleParameter] args | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:437:51:437:54 | [SimpleParameter] args | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:449:21:449:24 | [SimpleParameter] name | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:449:21:449:24 | [SimpleParameter] name | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:462:75:462:78 | [SimpleParameter] args | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:462:75:462:78 | [SimpleParameter] args | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:474:12:474:18 | [SimpleParameter] _target | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:474:12:474:18 | [SimpleParameter] _target | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:474:21:474:28 | [SimpleParameter] _context | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:474:21:474:28 | [SimpleParameter] _context | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:487:48:487:53 | [SimpleParameter] colors | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:487:48:487:53 | [SimpleParameter] colors | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:487:61:487:72 | [SimpleParameter] defaultColor | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:487:61:487:72 | [SimpleParameter] defaultColor | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:493:53:493:55 | [SimpleParameter] num | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:493:53:493:55 | [SimpleParameter] num | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:493:58:493:62 | [SimpleParameter] index | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:493:58:493:62 | [SimpleParameter] index | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:500:13:500:13 | [SimpleParameter] s | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:500:13:500:13 | [SimpleParameter] s | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:506:15:506:17 | [SimpleParameter] obj | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:506:15:506:17 | [SimpleParameter] obj | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | tst.ts:506:45:506:47 | [SimpleParameter] key | semmle.label | 1 | -| file://:0:0:0:0 | (Parameters) | tst.ts:506:45:506:47 | [SimpleParameter] key | semmle.order | 1 | -| file://:0:0:0:0 | (Parameters) | type_alias.ts:14:10:14:17 | [SimpleParameter] property | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | type_alias.ts:14:10:14:17 | [SimpleParameter] property | semmle.order | 0 | -| file://:0:0:0:0 | (Parameters) | type_alias.ts:21:19:21:21 | [SimpleParameter] key | semmle.label | 0 | -| file://:0:0:0:0 | (Parameters) | type_alias.ts:21:19:21:21 | [SimpleParameter] key | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:271:20:271:42 | [TypeParameter] P exten ... TypeMap | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:271:20:271:42 | [TypeParameter] P exten ... TypeMap | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:272:6:272:11 | [TypeParameter] K in P | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:272:6:272:11 | [TypeParameter] K in P | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:278:26:278:48 | [TypeParameter] K exten ... TypeMap | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:278:26:278:48 | [TypeParameter] K exten ... TypeMap | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:313:12:313:12 | [TypeParameter] T | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:313:12:313:12 | [TypeParameter] T | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:331:18:331:18 | [TypeParameter] T | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:331:18:331:18 | [TypeParameter] T | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:332:20:332:35 | [TypeParameter] S extends string | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:332:20:332:35 | [TypeParameter] S extends string | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:342:17:342:24 | [TypeParameter] in out T | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:342:17:342:24 | [TypeParameter] in out T | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:381:43:381:58 | [TypeParameter] U extends number | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:381:43:381:58 | [TypeParameter] U extends number | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:383:37:383:37 | [TypeParameter] T | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:383:37:383:37 | [TypeParameter] T | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:431:27:431:30 | [TypeParameter] This | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:431:27:431:30 | [TypeParameter] This | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:431:33:431:50 | [TypeParameter] Args extends any[] | semmle.label | 1 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:431:33:431:50 | [TypeParameter] Args extends any[] | semmle.order | 1 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:431:53:431:58 | [TypeParameter] Return | semmle.label | 2 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:431:53:431:58 | [TypeParameter] Return | semmle.order | 2 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:462:40:462:72 | [TypeParameter] const T ... tring[] | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:462:40:462:72 | [TypeParameter] const T ... tring[] | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:481:16:481:16 | [TypeParameter] T | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:481:16:481:16 | [TypeParameter] T | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:487:30:487:45 | [TypeParameter] C extends string | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | tst.ts:487:30:487:45 | [TypeParameter] C extends string | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | type_alias.ts:5:19:5:19 | [TypeParameter] T | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | type_alias.ts:5:19:5:19 | [TypeParameter] T | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | type_definitions.ts:3:13:3:13 | [TypeParameter] S | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | type_definitions.ts:3:13:3:13 | [TypeParameter] S | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | type_definitions.ts:8:9:8:9 | [TypeParameter] T | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | type_definitions.ts:8:9:8:9 | [TypeParameter] T | semmle.order | 0 | -| file://:0:0:0:0 | (TypeParameters) | type_definitions.ts:21:12:21:12 | [TypeParameter] T | semmle.label | 0 | -| file://:0:0:0:0 | (TypeParameters) | type_definitions.ts:21:12:21:12 | [TypeParameter] T | semmle.order | 0 | -| middle-rest.ts:1:1:1:40 | [DeclStmt] let foo = ... | middle-rest.ts:1:5:1:39 | [VariableDeclarator] foo: [b ... number] | semmle.label | 1 | -| middle-rest.ts:1:1:1:40 | [DeclStmt] let foo = ... | middle-rest.ts:1:5:1:39 | [VariableDeclarator] foo: [b ... number] | semmle.order | 1 | -| middle-rest.ts:1:5:1:39 | [VariableDeclarator] foo: [b ... number] | middle-rest.ts:1:5:1:7 | [VarDecl] foo | semmle.label | 1 | -| middle-rest.ts:1:5:1:39 | [VariableDeclarator] foo: [b ... number] | middle-rest.ts:1:5:1:7 | [VarDecl] foo | semmle.order | 1 | -| middle-rest.ts:1:5:1:39 | [VariableDeclarator] foo: [b ... number] | middle-rest.ts:1:10:1:39 | [TupleTypeExpr] [boolea ... number] | semmle.label | 2 | -| middle-rest.ts:1:5:1:39 | [VariableDeclarator] foo: [b ... number] | middle-rest.ts:1:10:1:39 | [TupleTypeExpr] [boolea ... number] | semmle.order | 2 | -| middle-rest.ts:1:10:1:39 | [TupleTypeExpr] [boolea ... number] | middle-rest.ts:1:11:1:17 | [KeywordTypeExpr] boolean | semmle.label | 1 | -| middle-rest.ts:1:10:1:39 | [TupleTypeExpr] [boolea ... number] | middle-rest.ts:1:11:1:17 | [KeywordTypeExpr] boolean | semmle.order | 1 | -| middle-rest.ts:1:10:1:39 | [TupleTypeExpr] [boolea ... number] | middle-rest.ts:1:20:1:30 | [RestTypeExpr] ...string[] | semmle.label | 2 | -| middle-rest.ts:1:10:1:39 | [TupleTypeExpr] [boolea ... number] | middle-rest.ts:1:20:1:30 | [RestTypeExpr] ...string[] | semmle.order | 2 | -| middle-rest.ts:1:10:1:39 | [TupleTypeExpr] [boolea ... number] | middle-rest.ts:1:33:1:38 | [KeywordTypeExpr] number | semmle.label | 3 | -| middle-rest.ts:1:10:1:39 | [TupleTypeExpr] [boolea ... number] | middle-rest.ts:1:33:1:38 | [KeywordTypeExpr] number | semmle.order | 3 | -| middle-rest.ts:1:20:1:30 | [RestTypeExpr] ...string[] | middle-rest.ts:1:23:1:30 | [ArrayTypeExpr] string[] | semmle.label | 1 | -| middle-rest.ts:1:20:1:30 | [RestTypeExpr] ...string[] | middle-rest.ts:1:23:1:30 | [ArrayTypeExpr] string[] | semmle.order | 1 | -| middle-rest.ts:1:23:1:30 | [ArrayTypeExpr] string[] | middle-rest.ts:1:23:1:28 | [KeywordTypeExpr] string | semmle.label | 1 | -| middle-rest.ts:1:23:1:30 | [ArrayTypeExpr] string[] | middle-rest.ts:1:23:1:28 | [KeywordTypeExpr] string | semmle.order | 1 | -| middle-rest.ts:3:1:3:26 | [AssignExpr] foo = [ ... ", 123] | middle-rest.ts:3:1:3:3 | [VarRef] foo | semmle.label | 1 | -| middle-rest.ts:3:1:3:26 | [AssignExpr] foo = [ ... ", 123] | middle-rest.ts:3:1:3:3 | [VarRef] foo | semmle.order | 1 | -| middle-rest.ts:3:1:3:26 | [AssignExpr] foo = [ ... ", 123] | middle-rest.ts:3:7:3:26 | [ArrayExpr] [true, "hello", 123] | semmle.label | 2 | -| middle-rest.ts:3:1:3:26 | [AssignExpr] foo = [ ... ", 123] | middle-rest.ts:3:7:3:26 | [ArrayExpr] [true, "hello", 123] | semmle.order | 2 | -| middle-rest.ts:3:1:3:27 | [ExprStmt] foo = [ ... , 123]; | middle-rest.ts:3:1:3:26 | [AssignExpr] foo = [ ... ", 123] | semmle.label | 1 | -| middle-rest.ts:3:1:3:27 | [ExprStmt] foo = [ ... , 123]; | middle-rest.ts:3:1:3:26 | [AssignExpr] foo = [ ... ", 123] | semmle.order | 1 | -| middle-rest.ts:3:7:3:26 | [ArrayExpr] [true, "hello", 123] | middle-rest.ts:3:8:3:11 | [Literal] true | semmle.label | 1 | -| middle-rest.ts:3:7:3:26 | [ArrayExpr] [true, "hello", 123] | middle-rest.ts:3:8:3:11 | [Literal] true | semmle.order | 1 | -| middle-rest.ts:3:7:3:26 | [ArrayExpr] [true, "hello", 123] | middle-rest.ts:3:14:3:20 | [Literal] "hello" | semmle.label | 2 | -| middle-rest.ts:3:7:3:26 | [ArrayExpr] [true, "hello", 123] | middle-rest.ts:3:14:3:20 | [Literal] "hello" | semmle.order | 2 | -| middle-rest.ts:3:7:3:26 | [ArrayExpr] [true, "hello", 123] | middle-rest.ts:3:23:3:25 | [Literal] 123 | semmle.label | 3 | -| middle-rest.ts:3:7:3:26 | [ArrayExpr] [true, "hello", 123] | middle-rest.ts:3:23:3:25 | [Literal] 123 | semmle.order | 3 | -| tsconfig.json:1:1:9:1 | [JsonObject] {compilerOptions: ...} | tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | semmle.label | 0 | -| tsconfig.json:1:1:9:1 | [JsonObject] {compilerOptions: ...} | tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | semmle.order | 0 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:3:15:3:22 | [JsonString] "esnext" | semmle.label | 0 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:3:15:3:22 | [JsonString] "esnext" | semmle.order | 0 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:4:15:4:22 | [JsonString] "esnext" | semmle.label | 1 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:4:15:4:22 | [JsonString] "esnext" | semmle.order | 1 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:5:12:5:28 | [JsonArray] ["dom", ...] | semmle.label | 2 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:5:12:5:28 | [JsonArray] ["dom", ...] | semmle.order | 2 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:6:26:6:29 | [JsonBoolean] true | semmle.label | 3 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:6:26:6:29 | [JsonBoolean] true | semmle.order | 3 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:7:23:7:34 | [JsonArray] [".ios", ...] | semmle.label | 4 | -| tsconfig.json:2:22:8:3 | [JsonObject] {module: ...} | tsconfig.json:7:23:7:34 | [JsonArray] [".ios", ...] | semmle.order | 4 | -| tsconfig.json:5:12:5:28 | [JsonArray] ["dom", ...] | tsconfig.json:5:13:5:17 | [JsonString] "dom" | semmle.label | 0 | -| tsconfig.json:5:12:5:28 | [JsonArray] ["dom", ...] | tsconfig.json:5:13:5:17 | [JsonString] "dom" | semmle.order | 0 | -| tsconfig.json:5:12:5:28 | [JsonArray] ["dom", ...] | tsconfig.json:5:20:5:27 | [JsonString] "esnext" | semmle.label | 1 | -| tsconfig.json:5:12:5:28 | [JsonArray] ["dom", ...] | tsconfig.json:5:20:5:27 | [JsonString] "esnext" | semmle.order | 1 | -| tsconfig.json:7:23:7:34 | [JsonArray] [".ios", ...] | tsconfig.json:7:24:7:29 | [JsonString] ".ios" | semmle.label | 0 | -| tsconfig.json:7:23:7:34 | [JsonArray] [".ios", ...] | tsconfig.json:7:24:7:29 | [JsonString] ".ios" | semmle.order | 0 | -| tsconfig.json:7:23:7:34 | [JsonArray] [".ios", ...] | tsconfig.json:7:32:7:33 | [JsonString] "" | semmle.label | 1 | -| tsconfig.json:7:23:7:34 | [JsonArray] [".ios", ...] | tsconfig.json:7:32:7:33 | [JsonString] "" | semmle.order | 1 | -| tst.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | tst.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.label | 1 | -| tst.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | tst.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.order | 1 | -| tst.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | tst.ts:1:24:1:32 | [Literal] "./dummy" | semmle.label | 2 | -| tst.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | tst.ts:1:24:1:32 | [Literal] "./dummy" | semmle.order | 2 | -| tst.ts:1:8:1:17 | [ImportSpecifier] * as dummy | tst.ts:1:13:1:17 | [VarDecl] dummy | semmle.label | 1 | -| tst.ts:1:8:1:17 | [ImportSpecifier] * as dummy | tst.ts:1:13:1:17 | [VarDecl] dummy | semmle.order | 1 | -| tst.ts:3:1:3:19 | [DeclStmt] var numVar = ... | tst.ts:3:5:3:18 | [VariableDeclarator] numVar: number | semmle.label | 1 | -| tst.ts:3:1:3:19 | [DeclStmt] var numVar = ... | tst.ts:3:5:3:18 | [VariableDeclarator] numVar: number | semmle.order | 1 | -| tst.ts:3:5:3:18 | [VariableDeclarator] numVar: number | tst.ts:3:5:3:10 | [VarDecl] numVar | semmle.label | 1 | -| tst.ts:3:5:3:18 | [VariableDeclarator] numVar: number | tst.ts:3:5:3:10 | [VarDecl] numVar | semmle.order | 1 | -| tst.ts:3:5:3:18 | [VariableDeclarator] numVar: number | tst.ts:3:13:3:18 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:3:5:3:18 | [VariableDeclarator] numVar: number | tst.ts:3:13:3:18 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:5:1:5:18 | [DeclStmt] var num1 = ... | tst.ts:5:5:5:17 | [VariableDeclarator] num1 = numVar | semmle.label | 1 | -| tst.ts:5:1:5:18 | [DeclStmt] var num1 = ... | tst.ts:5:5:5:17 | [VariableDeclarator] num1 = numVar | semmle.order | 1 | -| tst.ts:5:5:5:17 | [VariableDeclarator] num1 = numVar | tst.ts:5:5:5:8 | [VarDecl] num1 | semmle.label | 1 | -| tst.ts:5:5:5:17 | [VariableDeclarator] num1 = numVar | tst.ts:5:5:5:8 | [VarDecl] num1 | semmle.order | 1 | -| tst.ts:5:5:5:17 | [VariableDeclarator] num1 = numVar | tst.ts:5:12:5:17 | [VarRef] numVar | semmle.label | 2 | -| tst.ts:5:5:5:17 | [VariableDeclarator] num1 = numVar | tst.ts:5:12:5:17 | [VarRef] numVar | semmle.order | 2 | -| tst.ts:6:1:6:13 | [DeclStmt] var num2 = ... | tst.ts:6:5:6:12 | [VariableDeclarator] num2 = 5 | semmle.label | 1 | -| tst.ts:6:1:6:13 | [DeclStmt] var num2 = ... | tst.ts:6:5:6:12 | [VariableDeclarator] num2 = 5 | semmle.order | 1 | -| tst.ts:6:5:6:12 | [VariableDeclarator] num2 = 5 | tst.ts:6:5:6:8 | [VarDecl] num2 | semmle.label | 1 | -| tst.ts:6:5:6:12 | [VariableDeclarator] num2 = 5 | tst.ts:6:5:6:8 | [VarDecl] num2 | semmle.order | 1 | -| tst.ts:6:5:6:12 | [VariableDeclarator] num2 = 5 | tst.ts:6:12:6:12 | [Literal] 5 | semmle.label | 2 | -| tst.ts:6:5:6:12 | [VariableDeclarator] num2 = 5 | tst.ts:6:12:6:12 | [Literal] 5 | semmle.order | 2 | -| tst.ts:7:1:7:23 | [DeclStmt] var num3 = ... | tst.ts:7:5:7:22 | [VariableDeclarator] num3 = num1 + num2 | semmle.label | 1 | -| tst.ts:7:1:7:23 | [DeclStmt] var num3 = ... | tst.ts:7:5:7:22 | [VariableDeclarator] num3 = num1 + num2 | semmle.order | 1 | -| tst.ts:7:5:7:22 | [VariableDeclarator] num3 = num1 + num2 | tst.ts:7:5:7:8 | [VarDecl] num3 | semmle.label | 1 | -| tst.ts:7:5:7:22 | [VariableDeclarator] num3 = num1 + num2 | tst.ts:7:5:7:8 | [VarDecl] num3 | semmle.order | 1 | -| tst.ts:7:5:7:22 | [VariableDeclarator] num3 = num1 + num2 | tst.ts:7:12:7:22 | [BinaryExpr] num1 + num2 | semmle.label | 2 | -| tst.ts:7:5:7:22 | [VariableDeclarator] num3 = num1 + num2 | tst.ts:7:12:7:22 | [BinaryExpr] num1 + num2 | semmle.order | 2 | -| tst.ts:7:12:7:22 | [BinaryExpr] num1 + num2 | tst.ts:7:12:7:15 | [VarRef] num1 | semmle.label | 1 | -| tst.ts:7:12:7:22 | [BinaryExpr] num1 + num2 | tst.ts:7:12:7:15 | [VarRef] num1 | semmle.order | 1 | -| tst.ts:7:12:7:22 | [BinaryExpr] num1 + num2 | tst.ts:7:19:7:22 | [VarRef] num2 | semmle.label | 2 | -| tst.ts:7:12:7:22 | [BinaryExpr] num1 + num2 | tst.ts:7:19:7:22 | [VarRef] num2 | semmle.order | 2 | -| tst.ts:9:1:9:19 | [DeclStmt] var strVar = ... | tst.ts:9:5:9:18 | [VariableDeclarator] strVar: string | semmle.label | 1 | -| tst.ts:9:1:9:19 | [DeclStmt] var strVar = ... | tst.ts:9:5:9:18 | [VariableDeclarator] strVar: string | semmle.order | 1 | -| tst.ts:9:5:9:18 | [VariableDeclarator] strVar: string | tst.ts:9:5:9:10 | [VarDecl] strVar | semmle.label | 1 | -| tst.ts:9:5:9:18 | [VariableDeclarator] strVar: string | tst.ts:9:5:9:10 | [VarDecl] strVar | semmle.order | 1 | -| tst.ts:9:5:9:18 | [VariableDeclarator] strVar: string | tst.ts:9:13:9:18 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:9:5:9:18 | [VariableDeclarator] strVar: string | tst.ts:9:13:9:18 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:10:1:10:20 | [DeclStmt] var hello = ... | tst.ts:10:5:10:19 | [VariableDeclarator] hello = "hello" | semmle.label | 1 | -| tst.ts:10:1:10:20 | [DeclStmt] var hello = ... | tst.ts:10:5:10:19 | [VariableDeclarator] hello = "hello" | semmle.order | 1 | -| tst.ts:10:5:10:19 | [VariableDeclarator] hello = "hello" | tst.ts:10:5:10:9 | [VarDecl] hello | semmle.label | 1 | -| tst.ts:10:5:10:19 | [VariableDeclarator] hello = "hello" | tst.ts:10:5:10:9 | [VarDecl] hello | semmle.order | 1 | -| tst.ts:10:5:10:19 | [VariableDeclarator] hello = "hello" | tst.ts:10:13:10:19 | [Literal] "hello" | semmle.label | 2 | -| tst.ts:10:5:10:19 | [VariableDeclarator] hello = "hello" | tst.ts:10:13:10:19 | [Literal] "hello" | semmle.order | 2 | -| tst.ts:11:1:11:20 | [DeclStmt] var world = ... | tst.ts:11:5:11:19 | [VariableDeclarator] world = "world" | semmle.label | 1 | -| tst.ts:11:1:11:20 | [DeclStmt] var world = ... | tst.ts:11:5:11:19 | [VariableDeclarator] world = "world" | semmle.order | 1 | -| tst.ts:11:5:11:19 | [VariableDeclarator] world = "world" | tst.ts:11:5:11:9 | [VarDecl] world | semmle.label | 1 | -| tst.ts:11:5:11:19 | [VariableDeclarator] world = "world" | tst.ts:11:5:11:9 | [VarDecl] world | semmle.order | 1 | -| tst.ts:11:5:11:19 | [VariableDeclarator] world = "world" | tst.ts:11:13:11:19 | [Literal] "world" | semmle.label | 2 | -| tst.ts:11:5:11:19 | [VariableDeclarator] world = "world" | tst.ts:11:13:11:19 | [Literal] "world" | semmle.order | 2 | -| tst.ts:12:1:12:30 | [DeclStmt] var msg = ... | tst.ts:12:5:12:29 | [VariableDeclarator] msg = h ... + world | semmle.label | 1 | -| tst.ts:12:1:12:30 | [DeclStmt] var msg = ... | tst.ts:12:5:12:29 | [VariableDeclarator] msg = h ... + world | semmle.order | 1 | -| tst.ts:12:5:12:29 | [VariableDeclarator] msg = h ... + world | tst.ts:12:5:12:7 | [VarDecl] msg | semmle.label | 1 | -| tst.ts:12:5:12:29 | [VariableDeclarator] msg = h ... + world | tst.ts:12:5:12:7 | [VarDecl] msg | semmle.order | 1 | -| tst.ts:12:5:12:29 | [VariableDeclarator] msg = h ... + world | tst.ts:12:11:12:29 | [BinaryExpr] hello + " " + world | semmle.label | 2 | -| tst.ts:12:5:12:29 | [VariableDeclarator] msg = h ... + world | tst.ts:12:11:12:29 | [BinaryExpr] hello + " " + world | semmle.order | 2 | -| tst.ts:12:11:12:21 | [BinaryExpr] hello + " " | tst.ts:12:11:12:15 | [VarRef] hello | semmle.label | 1 | -| tst.ts:12:11:12:21 | [BinaryExpr] hello + " " | tst.ts:12:11:12:15 | [VarRef] hello | semmle.order | 1 | -| tst.ts:12:11:12:21 | [BinaryExpr] hello + " " | tst.ts:12:19:12:21 | [Literal] " " | semmle.label | 2 | -| tst.ts:12:11:12:21 | [BinaryExpr] hello + " " | tst.ts:12:19:12:21 | [Literal] " " | semmle.order | 2 | -| tst.ts:12:11:12:29 | [BinaryExpr] hello + " " + world | tst.ts:12:11:12:21 | [BinaryExpr] hello + " " | semmle.label | 1 | -| tst.ts:12:11:12:29 | [BinaryExpr] hello + " " + world | tst.ts:12:11:12:21 | [BinaryExpr] hello + " " | semmle.order | 1 | -| tst.ts:12:11:12:29 | [BinaryExpr] hello + " " + world | tst.ts:12:25:12:29 | [VarRef] world | semmle.label | 2 | -| tst.ts:12:11:12:29 | [BinaryExpr] hello + " " + world | tst.ts:12:25:12:29 | [VarRef] world | semmle.order | 2 | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | tst.ts:14:10:14:15 | [VarDecl] concat | semmle.label | 0 | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | tst.ts:14:10:14:15 | [VarDecl] concat | semmle.order | 0 | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | tst.ts:14:40:14:45 | [KeywordTypeExpr] string | semmle.label | 4 | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | tst.ts:14:40:14:45 | [KeywordTypeExpr] string | semmle.order | 4 | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | tst.ts:14:47:14:63 | [BlockStmt] { return x + y; } | semmle.label | 5 | -| tst.ts:14:1:14:63 | [FunctionDeclStmt] functio ... + y; } | tst.ts:14:47:14:63 | [BlockStmt] { return x + y; } | semmle.order | 5 | -| tst.ts:14:17:14:17 | [SimpleParameter] x | tst.ts:14:20:14:25 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:14:17:14:17 | [SimpleParameter] x | tst.ts:14:20:14:25 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:14:28:14:28 | [SimpleParameter] y | tst.ts:14:31:14:36 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:14:28:14:28 | [SimpleParameter] y | tst.ts:14:31:14:36 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:14:47:14:63 | [BlockStmt] { return x + y; } | tst.ts:14:49:14:61 | [ReturnStmt] return x + y; | semmle.label | 1 | -| tst.ts:14:47:14:63 | [BlockStmt] { return x + y; } | tst.ts:14:49:14:61 | [ReturnStmt] return x + y; | semmle.order | 1 | -| tst.ts:14:49:14:61 | [ReturnStmt] return x + y; | tst.ts:14:56:14:60 | [BinaryExpr] x + y | semmle.label | 1 | -| tst.ts:14:49:14:61 | [ReturnStmt] return x + y; | tst.ts:14:56:14:60 | [BinaryExpr] x + y | semmle.order | 1 | -| tst.ts:14:56:14:60 | [BinaryExpr] x + y | tst.ts:14:56:14:56 | [VarRef] x | semmle.label | 1 | -| tst.ts:14:56:14:60 | [BinaryExpr] x + y | tst.ts:14:56:14:56 | [VarRef] x | semmle.order | 1 | -| tst.ts:14:56:14:60 | [BinaryExpr] x + y | tst.ts:14:60:14:60 | [VarRef] y | semmle.label | 2 | -| tst.ts:14:56:14:60 | [BinaryExpr] x + y | tst.ts:14:60:14:60 | [VarRef] y | semmle.order | 2 | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | tst.ts:16:10:16:12 | [VarDecl] add | semmle.label | 0 | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | tst.ts:16:10:16:12 | [VarDecl] add | semmle.order | 0 | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | tst.ts:16:37:16:42 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | tst.ts:16:37:16:42 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | tst.ts:16:44:16:60 | [BlockStmt] { return x + y; } | semmle.label | 5 | -| tst.ts:16:1:16:60 | [FunctionDeclStmt] functio ... + y; } | tst.ts:16:44:16:60 | [BlockStmt] { return x + y; } | semmle.order | 5 | -| tst.ts:16:14:16:14 | [SimpleParameter] x | tst.ts:16:17:16:22 | [KeywordTypeExpr] number | semmle.label | -2 | -| tst.ts:16:14:16:14 | [SimpleParameter] x | tst.ts:16:17:16:22 | [KeywordTypeExpr] number | semmle.order | -2 | -| tst.ts:16:25:16:25 | [SimpleParameter] y | tst.ts:16:28:16:33 | [KeywordTypeExpr] number | semmle.label | -2 | -| tst.ts:16:25:16:25 | [SimpleParameter] y | tst.ts:16:28:16:33 | [KeywordTypeExpr] number | semmle.order | -2 | -| tst.ts:16:44:16:60 | [BlockStmt] { return x + y; } | tst.ts:16:46:16:58 | [ReturnStmt] return x + y; | semmle.label | 1 | -| tst.ts:16:44:16:60 | [BlockStmt] { return x + y; } | tst.ts:16:46:16:58 | [ReturnStmt] return x + y; | semmle.order | 1 | -| tst.ts:16:46:16:58 | [ReturnStmt] return x + y; | tst.ts:16:53:16:57 | [BinaryExpr] x + y | semmle.label | 1 | -| tst.ts:16:46:16:58 | [ReturnStmt] return x + y; | tst.ts:16:53:16:57 | [BinaryExpr] x + y | semmle.order | 1 | -| tst.ts:16:53:16:57 | [BinaryExpr] x + y | tst.ts:16:53:16:53 | [VarRef] x | semmle.label | 1 | -| tst.ts:16:53:16:57 | [BinaryExpr] x + y | tst.ts:16:53:16:53 | [VarRef] x | semmle.order | 1 | -| tst.ts:16:53:16:57 | [BinaryExpr] x + y | tst.ts:16:57:16:57 | [VarRef] y | semmle.label | 2 | -| tst.ts:16:53:16:57 | [BinaryExpr] x + y | tst.ts:16:57:16:57 | [VarRef] y | semmle.order | 2 | -| tst.ts:18:1:18:40 | [FunctionDeclStmt] functio ... + y; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:18:1:18:40 | [FunctionDeclStmt] functio ... + y; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:18:1:18:40 | [FunctionDeclStmt] functio ... + y; } | tst.ts:18:10:18:16 | [VarDecl] untyped | semmle.label | 0 | -| tst.ts:18:1:18:40 | [FunctionDeclStmt] functio ... + y; } | tst.ts:18:10:18:16 | [VarDecl] untyped | semmle.order | 0 | -| tst.ts:18:1:18:40 | [FunctionDeclStmt] functio ... + y; } | tst.ts:18:24:18:40 | [BlockStmt] { return x + y; } | semmle.label | 5 | -| tst.ts:18:1:18:40 | [FunctionDeclStmt] functio ... + y; } | tst.ts:18:24:18:40 | [BlockStmt] { return x + y; } | semmle.order | 5 | -| tst.ts:18:24:18:40 | [BlockStmt] { return x + y; } | tst.ts:18:26:18:38 | [ReturnStmt] return x + y; | semmle.label | 1 | -| tst.ts:18:24:18:40 | [BlockStmt] { return x + y; } | tst.ts:18:26:18:38 | [ReturnStmt] return x + y; | semmle.order | 1 | -| tst.ts:18:26:18:38 | [ReturnStmt] return x + y; | tst.ts:18:33:18:37 | [BinaryExpr] x + y | semmle.label | 1 | -| tst.ts:18:26:18:38 | [ReturnStmt] return x + y; | tst.ts:18:33:18:37 | [BinaryExpr] x + y | semmle.order | 1 | -| tst.ts:18:33:18:37 | [BinaryExpr] x + y | tst.ts:18:33:18:33 | [VarRef] x | semmle.label | 1 | -| tst.ts:18:33:18:37 | [BinaryExpr] x + y | tst.ts:18:33:18:33 | [VarRef] x | semmle.order | 1 | -| tst.ts:18:33:18:37 | [BinaryExpr] x + y | tst.ts:18:37:18:37 | [VarRef] y | semmle.label | 2 | -| tst.ts:18:33:18:37 | [BinaryExpr] x + y | tst.ts:18:37:18:37 | [VarRef] y | semmle.order | 2 | -| tst.ts:20:1:20:53 | [FunctionDeclStmt] functio ... + y; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:20:1:20:53 | [FunctionDeclStmt] functio ... + y; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:20:1:20:53 | [FunctionDeclStmt] functio ... + y; } | tst.ts:20:10:20:21 | [VarDecl] partialTyped | semmle.label | 0 | -| tst.ts:20:1:20:53 | [FunctionDeclStmt] functio ... + y; } | tst.ts:20:10:20:21 | [VarDecl] partialTyped | semmle.order | 0 | -| tst.ts:20:1:20:53 | [FunctionDeclStmt] functio ... + y; } | tst.ts:20:37:20:53 | [BlockStmt] { return x + y; } | semmle.label | 5 | -| tst.ts:20:1:20:53 | [FunctionDeclStmt] functio ... + y; } | tst.ts:20:37:20:53 | [BlockStmt] { return x + y; } | semmle.order | 5 | -| tst.ts:20:26:20:26 | [SimpleParameter] y | tst.ts:20:29:20:34 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:20:26:20:26 | [SimpleParameter] y | tst.ts:20:29:20:34 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:20:37:20:53 | [BlockStmt] { return x + y; } | tst.ts:20:39:20:51 | [ReturnStmt] return x + y; | semmle.label | 1 | -| tst.ts:20:37:20:53 | [BlockStmt] { return x + y; } | tst.ts:20:39:20:51 | [ReturnStmt] return x + y; | semmle.order | 1 | -| tst.ts:20:39:20:51 | [ReturnStmt] return x + y; | tst.ts:20:46:20:50 | [BinaryExpr] x + y | semmle.label | 1 | -| tst.ts:20:39:20:51 | [ReturnStmt] return x + y; | tst.ts:20:46:20:50 | [BinaryExpr] x + y | semmle.order | 1 | -| tst.ts:20:46:20:50 | [BinaryExpr] x + y | tst.ts:20:46:20:46 | [VarRef] x | semmle.label | 1 | -| tst.ts:20:46:20:50 | [BinaryExpr] x + y | tst.ts:20:46:20:46 | [VarRef] x | semmle.order | 1 | -| tst.ts:20:46:20:50 | [BinaryExpr] x + y | tst.ts:20:50:20:50 | [VarRef] y | semmle.label | 2 | -| tst.ts:20:46:20:50 | [BinaryExpr] x + y | tst.ts:20:50:20:50 | [VarRef] y | semmle.order | 2 | -| tst.ts:22:1:22:34 | [ForOfStmt] for (le ... 2]) {} | tst.ts:22:6:22:20 | [DeclStmt] let numFromLoop = ... | semmle.label | 1 | -| tst.ts:22:1:22:34 | [ForOfStmt] for (le ... 2]) {} | tst.ts:22:6:22:20 | [DeclStmt] let numFromLoop = ... | semmle.order | 1 | -| tst.ts:22:1:22:34 | [ForOfStmt] for (le ... 2]) {} | tst.ts:22:25:22:30 | [ArrayExpr] [1, 2] | semmle.label | 2 | -| tst.ts:22:1:22:34 | [ForOfStmt] for (le ... 2]) {} | tst.ts:22:25:22:30 | [ArrayExpr] [1, 2] | semmle.order | 2 | -| tst.ts:22:1:22:34 | [ForOfStmt] for (le ... 2]) {} | tst.ts:22:33:22:34 | [BlockStmt] {} | semmle.label | 3 | -| tst.ts:22:1:22:34 | [ForOfStmt] for (le ... 2]) {} | tst.ts:22:33:22:34 | [BlockStmt] {} | semmle.order | 3 | -| tst.ts:22:6:22:20 | [DeclStmt] let numFromLoop = ... | tst.ts:22:10:22:20 | [VariableDeclarator] numFromLoop | semmle.label | 1 | -| tst.ts:22:6:22:20 | [DeclStmt] let numFromLoop = ... | tst.ts:22:10:22:20 | [VariableDeclarator] numFromLoop | semmle.order | 1 | -| tst.ts:22:10:22:20 | [VariableDeclarator] numFromLoop | tst.ts:22:10:22:20 | [VarDecl] numFromLoop | semmle.label | 1 | -| tst.ts:22:10:22:20 | [VariableDeclarator] numFromLoop | tst.ts:22:10:22:20 | [VarDecl] numFromLoop | semmle.order | 1 | -| tst.ts:22:25:22:30 | [ArrayExpr] [1, 2] | tst.ts:22:26:22:26 | [Literal] 1 | semmle.label | 1 | -| tst.ts:22:25:22:30 | [ArrayExpr] [1, 2] | tst.ts:22:26:22:26 | [Literal] 1 | semmle.order | 1 | -| tst.ts:22:25:22:30 | [ArrayExpr] [1, 2] | tst.ts:22:29:22:29 | [Literal] 2 | semmle.label | 2 | -| tst.ts:22:25:22:30 | [ArrayExpr] [1, 2] | tst.ts:22:29:22:29 | [Literal] 2 | semmle.order | 2 | -| tst.ts:24:1:24:20 | [DeclStmt] let array = ... | tst.ts:24:5:24:19 | [VariableDeclarator] array: number[] | semmle.label | 1 | -| tst.ts:24:1:24:20 | [DeclStmt] let array = ... | tst.ts:24:5:24:19 | [VariableDeclarator] array: number[] | semmle.order | 1 | -| tst.ts:24:5:24:19 | [VariableDeclarator] array: number[] | tst.ts:24:5:24:9 | [VarDecl] array | semmle.label | 1 | -| tst.ts:24:5:24:19 | [VariableDeclarator] array: number[] | tst.ts:24:5:24:9 | [VarDecl] array | semmle.order | 1 | -| tst.ts:24:5:24:19 | [VariableDeclarator] array: number[] | tst.ts:24:12:24:19 | [ArrayTypeExpr] number[] | semmle.label | 2 | -| tst.ts:24:5:24:19 | [VariableDeclarator] array: number[] | tst.ts:24:12:24:19 | [ArrayTypeExpr] number[] | semmle.order | 2 | -| tst.ts:24:12:24:19 | [ArrayTypeExpr] number[] | tst.ts:24:12:24:17 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:24:12:24:19 | [ArrayTypeExpr] number[] | tst.ts:24:12:24:17 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:26:1:26:25 | [DeclStmt] let voidType = ... | tst.ts:26:5:26:24 | [VariableDeclarator] voidType: () => void | semmle.label | 1 | -| tst.ts:26:1:26:25 | [DeclStmt] let voidType = ... | tst.ts:26:5:26:24 | [VariableDeclarator] voidType: () => void | semmle.order | 1 | -| tst.ts:26:5:26:24 | [VariableDeclarator] voidType: () => void | tst.ts:26:5:26:12 | [VarDecl] voidType | semmle.label | 1 | -| tst.ts:26:5:26:24 | [VariableDeclarator] voidType: () => void | tst.ts:26:5:26:12 | [VarDecl] voidType | semmle.order | 1 | -| tst.ts:26:5:26:24 | [VariableDeclarator] voidType: () => void | tst.ts:26:15:26:24 | [FunctionTypeExpr] () => void | semmle.label | 2 | -| tst.ts:26:5:26:24 | [VariableDeclarator] voidType: () => void | tst.ts:26:15:26:24 | [FunctionTypeExpr] () => void | semmle.order | 2 | -| tst.ts:26:15:26:24 | [FunctionExpr] () => void | tst.ts:26:21:26:24 | [KeywordTypeExpr] void | semmle.label | 4 | -| tst.ts:26:15:26:24 | [FunctionExpr] () => void | tst.ts:26:21:26:24 | [KeywordTypeExpr] void | semmle.order | 4 | -| tst.ts:26:15:26:24 | [FunctionTypeExpr] () => void | tst.ts:26:15:26:24 | [FunctionExpr] () => void | semmle.label | 1 | -| tst.ts:26:15:26:24 | [FunctionTypeExpr] () => void | tst.ts:26:15:26:24 | [FunctionExpr] () => void | semmle.order | 1 | -| tst.ts:27:1:27:29 | [DeclStmt] let undefinedType = ... | tst.ts:27:5:27:28 | [VariableDeclarator] undefin ... defined | semmle.label | 1 | -| tst.ts:27:1:27:29 | [DeclStmt] let undefinedType = ... | tst.ts:27:5:27:28 | [VariableDeclarator] undefin ... defined | semmle.order | 1 | -| tst.ts:27:5:27:28 | [VariableDeclarator] undefin ... defined | tst.ts:27:5:27:17 | [VarDecl] undefinedType | semmle.label | 1 | -| tst.ts:27:5:27:28 | [VariableDeclarator] undefin ... defined | tst.ts:27:5:27:17 | [VarDecl] undefinedType | semmle.order | 1 | -| tst.ts:27:5:27:28 | [VariableDeclarator] undefin ... defined | tst.ts:27:20:27:28 | [KeywordTypeExpr] undefined | semmle.label | 2 | -| tst.ts:27:5:27:28 | [VariableDeclarator] undefin ... defined | tst.ts:27:20:27:28 | [KeywordTypeExpr] undefined | semmle.order | 2 | -| tst.ts:28:1:28:26 | [DeclStmt] let nullType = ... | tst.ts:28:5:28:25 | [VariableDeclarator] nullTyp ... = null | semmle.label | 1 | -| tst.ts:28:1:28:26 | [DeclStmt] let nullType = ... | tst.ts:28:5:28:25 | [VariableDeclarator] nullTyp ... = null | semmle.order | 1 | -| tst.ts:28:5:28:25 | [VariableDeclarator] nullTyp ... = null | tst.ts:28:5:28:12 | [VarDecl] nullType | semmle.label | 1 | -| tst.ts:28:5:28:25 | [VariableDeclarator] nullTyp ... = null | tst.ts:28:5:28:12 | [VarDecl] nullType | semmle.order | 1 | -| tst.ts:28:5:28:25 | [VariableDeclarator] nullTyp ... = null | tst.ts:28:15:28:18 | [KeywordTypeExpr] null | semmle.label | 2 | -| tst.ts:28:5:28:25 | [VariableDeclarator] nullTyp ... = null | tst.ts:28:15:28:18 | [KeywordTypeExpr] null | semmle.order | 2 | -| tst.ts:28:5:28:25 | [VariableDeclarator] nullTyp ... = null | tst.ts:28:22:28:25 | [Literal] null | semmle.label | 3 | -| tst.ts:28:5:28:25 | [VariableDeclarator] nullTyp ... = null | tst.ts:28:22:28:25 | [Literal] null | semmle.order | 3 | -| tst.ts:29:1:29:27 | [DeclStmt] let neverType = ... | tst.ts:29:5:29:26 | [VariableDeclarator] neverTy ... > never | semmle.label | 1 | -| tst.ts:29:1:29:27 | [DeclStmt] let neverType = ... | tst.ts:29:5:29:26 | [VariableDeclarator] neverTy ... > never | semmle.order | 1 | -| tst.ts:29:5:29:26 | [VariableDeclarator] neverTy ... > never | tst.ts:29:5:29:13 | [VarDecl] neverType | semmle.label | 1 | -| tst.ts:29:5:29:26 | [VariableDeclarator] neverTy ... > never | tst.ts:29:5:29:13 | [VarDecl] neverType | semmle.order | 1 | -| tst.ts:29:5:29:26 | [VariableDeclarator] neverTy ... > never | tst.ts:29:16:29:26 | [FunctionTypeExpr] () => never | semmle.label | 2 | -| tst.ts:29:5:29:26 | [VariableDeclarator] neverTy ... > never | tst.ts:29:16:29:26 | [FunctionTypeExpr] () => never | semmle.order | 2 | -| tst.ts:29:16:29:26 | [FunctionExpr] () => never | tst.ts:29:22:29:26 | [KeywordTypeExpr] never | semmle.label | 4 | -| tst.ts:29:16:29:26 | [FunctionExpr] () => never | tst.ts:29:22:29:26 | [KeywordTypeExpr] never | semmle.order | 4 | -| tst.ts:29:16:29:26 | [FunctionTypeExpr] () => never | tst.ts:29:16:29:26 | [FunctionExpr] () => never | semmle.label | 1 | -| tst.ts:29:16:29:26 | [FunctionTypeExpr] () => never | tst.ts:29:16:29:26 | [FunctionExpr] () => never | semmle.order | 1 | -| tst.ts:30:1:30:23 | [DeclStmt] let symbolType = ... | tst.ts:30:5:30:22 | [VariableDeclarator] symbolType: symbol | semmle.label | 1 | -| tst.ts:30:1:30:23 | [DeclStmt] let symbolType = ... | tst.ts:30:5:30:22 | [VariableDeclarator] symbolType: symbol | semmle.order | 1 | -| tst.ts:30:5:30:22 | [VariableDeclarator] symbolType: symbol | tst.ts:30:5:30:14 | [VarDecl] symbolType | semmle.label | 1 | -| tst.ts:30:5:30:22 | [VariableDeclarator] symbolType: symbol | tst.ts:30:5:30:14 | [VarDecl] symbolType | semmle.order | 1 | -| tst.ts:30:5:30:22 | [VariableDeclarator] symbolType: symbol | tst.ts:30:17:30:22 | [KeywordTypeExpr] symbol | semmle.label | 2 | -| tst.ts:30:5:30:22 | [VariableDeclarator] symbolType: symbol | tst.ts:30:17:30:22 | [KeywordTypeExpr] symbol | semmle.order | 2 | -| tst.ts:31:1:31:45 | [DeclStmt] const uniqueSymbolType = ... | tst.ts:31:7:31:44 | [VariableDeclarator] uniqueS ... = null | semmle.label | 1 | -| tst.ts:31:1:31:45 | [DeclStmt] const uniqueSymbolType = ... | tst.ts:31:7:31:44 | [VariableDeclarator] uniqueS ... = null | semmle.order | 1 | -| tst.ts:31:7:31:44 | [VariableDeclarator] uniqueS ... = null | tst.ts:31:7:31:22 | [VarDecl] uniqueSymbolType | semmle.label | 1 | -| tst.ts:31:7:31:44 | [VariableDeclarator] uniqueS ... = null | tst.ts:31:7:31:22 | [VarDecl] uniqueSymbolType | semmle.order | 1 | -| tst.ts:31:7:31:44 | [VariableDeclarator] uniqueS ... = null | tst.ts:31:25:31:37 | [KeywordTypeExpr] unique symbol | semmle.label | 2 | -| tst.ts:31:7:31:44 | [VariableDeclarator] uniqueS ... = null | tst.ts:31:25:31:37 | [KeywordTypeExpr] unique symbol | semmle.order | 2 | -| tst.ts:31:7:31:44 | [VariableDeclarator] uniqueS ... = null | tst.ts:31:41:31:44 | [Literal] null | semmle.label | 3 | -| tst.ts:31:7:31:44 | [VariableDeclarator] uniqueS ... = null | tst.ts:31:41:31:44 | [Literal] null | semmle.order | 3 | -| tst.ts:32:1:32:23 | [DeclStmt] let objectType = ... | tst.ts:32:5:32:22 | [VariableDeclarator] objectType: object | semmle.label | 1 | -| tst.ts:32:1:32:23 | [DeclStmt] let objectType = ... | tst.ts:32:5:32:22 | [VariableDeclarator] objectType: object | semmle.order | 1 | -| tst.ts:32:5:32:22 | [VariableDeclarator] objectType: object | tst.ts:32:5:32:14 | [VarDecl] objectType | semmle.label | 1 | -| tst.ts:32:5:32:22 | [VariableDeclarator] objectType: object | tst.ts:32:5:32:14 | [VarDecl] objectType | semmle.order | 1 | -| tst.ts:32:5:32:22 | [VariableDeclarator] objectType: object | tst.ts:32:17:32:22 | [KeywordTypeExpr] object | semmle.label | 2 | -| tst.ts:32:5:32:22 | [VariableDeclarator] objectType: object | tst.ts:32:17:32:22 | [KeywordTypeExpr] object | semmle.order | 2 | -| tst.ts:33:1:33:39 | [DeclStmt] let intersection = ... | tst.ts:33:5:33:38 | [VariableDeclarator] interse ... string} | semmle.label | 1 | -| tst.ts:33:1:33:39 | [DeclStmt] let intersection = ... | tst.ts:33:5:33:38 | [VariableDeclarator] interse ... string} | semmle.order | 1 | -| tst.ts:33:5:33:38 | [VariableDeclarator] interse ... string} | tst.ts:33:5:33:16 | [VarDecl] intersection | semmle.label | 1 | -| tst.ts:33:5:33:38 | [VariableDeclarator] interse ... string} | tst.ts:33:5:33:16 | [VarDecl] intersection | semmle.order | 1 | -| tst.ts:33:5:33:38 | [VariableDeclarator] interse ... string} | tst.ts:33:19:33:38 | [IntersectionTypeExpr] string & {x: string} | semmle.label | 2 | -| tst.ts:33:5:33:38 | [VariableDeclarator] interse ... string} | tst.ts:33:19:33:38 | [IntersectionTypeExpr] string & {x: string} | semmle.order | 2 | -| tst.ts:33:19:33:38 | [IntersectionTypeExpr] string & {x: string} | tst.ts:33:19:33:24 | [KeywordTypeExpr] string | semmle.label | 1 | -| tst.ts:33:19:33:38 | [IntersectionTypeExpr] string & {x: string} | tst.ts:33:19:33:24 | [KeywordTypeExpr] string | semmle.order | 1 | -| tst.ts:33:19:33:38 | [IntersectionTypeExpr] string & {x: string} | tst.ts:33:28:33:38 | [InterfaceTypeExpr] {x: string} | semmle.label | 2 | -| tst.ts:33:19:33:38 | [IntersectionTypeExpr] string & {x: string} | tst.ts:33:28:33:38 | [InterfaceTypeExpr] {x: string} | semmle.order | 2 | -| tst.ts:33:28:33:38 | [InterfaceTypeExpr] {x: string} | tst.ts:33:29:33:37 | [FieldDeclaration] x: string | semmle.label | 1 | -| tst.ts:33:28:33:38 | [InterfaceTypeExpr] {x: string} | tst.ts:33:29:33:37 | [FieldDeclaration] x: string | semmle.order | 1 | -| tst.ts:33:29:33:37 | [FieldDeclaration] x: string | tst.ts:33:29:33:29 | [Label] x | semmle.label | 1 | -| tst.ts:33:29:33:37 | [FieldDeclaration] x: string | tst.ts:33:29:33:29 | [Label] x | semmle.order | 1 | -| tst.ts:33:29:33:37 | [FieldDeclaration] x: string | tst.ts:33:32:33:37 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:33:29:33:37 | [FieldDeclaration] x: string | tst.ts:33:32:33:37 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:34:1:34:28 | [DeclStmt] let tuple = ... | tst.ts:34:5:34:27 | [VariableDeclarator] tuple: ... string] | semmle.label | 1 | -| tst.ts:34:1:34:28 | [DeclStmt] let tuple = ... | tst.ts:34:5:34:27 | [VariableDeclarator] tuple: ... string] | semmle.order | 1 | -| tst.ts:34:5:34:27 | [VariableDeclarator] tuple: ... string] | tst.ts:34:5:34:9 | [VarDecl] tuple | semmle.label | 1 | -| tst.ts:34:5:34:27 | [VariableDeclarator] tuple: ... string] | tst.ts:34:5:34:9 | [VarDecl] tuple | semmle.order | 1 | -| tst.ts:34:5:34:27 | [VariableDeclarator] tuple: ... string] | tst.ts:34:12:34:27 | [TupleTypeExpr] [number, string] | semmle.label | 2 | -| tst.ts:34:5:34:27 | [VariableDeclarator] tuple: ... string] | tst.ts:34:12:34:27 | [TupleTypeExpr] [number, string] | semmle.order | 2 | -| tst.ts:34:12:34:27 | [TupleTypeExpr] [number, string] | tst.ts:34:13:34:18 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:34:12:34:27 | [TupleTypeExpr] [number, string] | tst.ts:34:13:34:18 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:34:12:34:27 | [TupleTypeExpr] [number, string] | tst.ts:34:21:34:26 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:34:12:34:27 | [TupleTypeExpr] [number, string] | tst.ts:34:21:34:26 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:36:1:36:56 | [DeclStmt] let tupleWithOptionalElement = ... | tst.ts:36:5:36:55 | [VariableDeclarator] tupleWi ... umber?] | semmle.label | 1 | -| tst.ts:36:1:36:56 | [DeclStmt] let tupleWithOptionalElement = ... | tst.ts:36:5:36:55 | [VariableDeclarator] tupleWi ... umber?] | semmle.order | 1 | -| tst.ts:36:5:36:55 | [VariableDeclarator] tupleWi ... umber?] | tst.ts:36:5:36:28 | [VarDecl] tupleWithOptionalElement | semmle.label | 1 | -| tst.ts:36:5:36:55 | [VariableDeclarator] tupleWi ... umber?] | tst.ts:36:5:36:28 | [VarDecl] tupleWithOptionalElement | semmle.order | 1 | -| tst.ts:36:5:36:55 | [VariableDeclarator] tupleWi ... umber?] | tst.ts:36:31:36:55 | [TupleTypeExpr] [number ... umber?] | semmle.label | 2 | -| tst.ts:36:5:36:55 | [VariableDeclarator] tupleWi ... umber?] | tst.ts:36:31:36:55 | [TupleTypeExpr] [number ... umber?] | semmle.order | 2 | -| tst.ts:36:31:36:55 | [TupleTypeExpr] [number ... umber?] | tst.ts:36:32:36:37 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:36:31:36:55 | [TupleTypeExpr] [number ... umber?] | tst.ts:36:32:36:37 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:36:31:36:55 | [TupleTypeExpr] [number ... umber?] | tst.ts:36:40:36:45 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:36:31:36:55 | [TupleTypeExpr] [number ... umber?] | tst.ts:36:40:36:45 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:36:31:36:55 | [TupleTypeExpr] [number ... umber?] | tst.ts:36:48:36:54 | [OptionalTypeExpr] number? | semmle.label | 3 | -| tst.ts:36:31:36:55 | [TupleTypeExpr] [number ... umber?] | tst.ts:36:48:36:54 | [OptionalTypeExpr] number? | semmle.order | 3 | -| tst.ts:36:48:36:54 | [OptionalTypeExpr] number? | tst.ts:36:48:36:53 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:36:48:36:54 | [OptionalTypeExpr] number? | tst.ts:36:48:36:53 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:37:1:37:19 | [DeclStmt] let emptyTuple = ... | tst.ts:37:5:37:18 | [VariableDeclarator] emptyTuple: [] | semmle.label | 1 | -| tst.ts:37:1:37:19 | [DeclStmt] let emptyTuple = ... | tst.ts:37:5:37:18 | [VariableDeclarator] emptyTuple: [] | semmle.order | 1 | -| tst.ts:37:5:37:18 | [VariableDeclarator] emptyTuple: [] | tst.ts:37:5:37:14 | [VarDecl] emptyTuple | semmle.label | 1 | -| tst.ts:37:5:37:18 | [VariableDeclarator] emptyTuple: [] | tst.ts:37:5:37:14 | [VarDecl] emptyTuple | semmle.order | 1 | -| tst.ts:37:5:37:18 | [VariableDeclarator] emptyTuple: [] | tst.ts:37:17:37:18 | [TupleTypeExpr] [] | semmle.label | 2 | -| tst.ts:37:5:37:18 | [VariableDeclarator] emptyTuple: [] | tst.ts:37:17:37:18 | [TupleTypeExpr] [] | semmle.order | 2 | -| tst.ts:38:1:38:48 | [DeclStmt] let tupleWithRestElement = ... | tst.ts:38:5:38:47 | [VariableDeclarator] tupleWi ... ring[]] | semmle.label | 1 | -| tst.ts:38:1:38:48 | [DeclStmt] let tupleWithRestElement = ... | tst.ts:38:5:38:47 | [VariableDeclarator] tupleWi ... ring[]] | semmle.order | 1 | -| tst.ts:38:5:38:47 | [VariableDeclarator] tupleWi ... ring[]] | tst.ts:38:5:38:24 | [VarDecl] tupleWithRestElement | semmle.label | 1 | -| tst.ts:38:5:38:47 | [VariableDeclarator] tupleWi ... ring[]] | tst.ts:38:5:38:24 | [VarDecl] tupleWithRestElement | semmle.order | 1 | -| tst.ts:38:5:38:47 | [VariableDeclarator] tupleWi ... ring[]] | tst.ts:38:27:38:47 | [TupleTypeExpr] [number ... ring[]] | semmle.label | 2 | -| tst.ts:38:5:38:47 | [VariableDeclarator] tupleWi ... ring[]] | tst.ts:38:27:38:47 | [TupleTypeExpr] [number ... ring[]] | semmle.order | 2 | -| tst.ts:38:27:38:47 | [TupleTypeExpr] [number ... ring[]] | tst.ts:38:28:38:33 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:38:27:38:47 | [TupleTypeExpr] [number ... ring[]] | tst.ts:38:28:38:33 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:38:27:38:47 | [TupleTypeExpr] [number ... ring[]] | tst.ts:38:36:38:46 | [RestTypeExpr] ...string[] | semmle.label | 2 | -| tst.ts:38:27:38:47 | [TupleTypeExpr] [number ... ring[]] | tst.ts:38:36:38:46 | [RestTypeExpr] ...string[] | semmle.order | 2 | -| tst.ts:38:36:38:46 | [RestTypeExpr] ...string[] | tst.ts:38:39:38:46 | [ArrayTypeExpr] string[] | semmle.label | 1 | -| tst.ts:38:36:38:46 | [RestTypeExpr] ...string[] | tst.ts:38:39:38:46 | [ArrayTypeExpr] string[] | semmle.order | 1 | -| tst.ts:38:39:38:46 | [ArrayTypeExpr] string[] | tst.ts:38:39:38:44 | [KeywordTypeExpr] string | semmle.label | 1 | -| tst.ts:38:39:38:46 | [ArrayTypeExpr] string[] | tst.ts:38:39:38:44 | [KeywordTypeExpr] string | semmle.order | 1 | -| tst.ts:39:1:39:69 | [DeclStmt] let tupleWithOptionalAndRestElements = ... | tst.ts:39:5:39:68 | [VariableDeclarator] tupleWi ... mber[]] | semmle.label | 1 | -| tst.ts:39:1:39:69 | [DeclStmt] let tupleWithOptionalAndRestElements = ... | tst.ts:39:5:39:68 | [VariableDeclarator] tupleWi ... mber[]] | semmle.order | 1 | -| tst.ts:39:5:39:68 | [VariableDeclarator] tupleWi ... mber[]] | tst.ts:39:5:39:36 | [VarDecl] tupleWithOptionalAndRestElements | semmle.label | 1 | -| tst.ts:39:5:39:68 | [VariableDeclarator] tupleWi ... mber[]] | tst.ts:39:5:39:36 | [VarDecl] tupleWithOptionalAndRestElements | semmle.order | 1 | -| tst.ts:39:5:39:68 | [VariableDeclarator] tupleWi ... mber[]] | tst.ts:39:39:39:68 | [TupleTypeExpr] [number ... mber[]] | semmle.label | 2 | -| tst.ts:39:5:39:68 | [VariableDeclarator] tupleWi ... mber[]] | tst.ts:39:39:39:68 | [TupleTypeExpr] [number ... mber[]] | semmle.order | 2 | -| tst.ts:39:39:39:68 | [TupleTypeExpr] [number ... mber[]] | tst.ts:39:40:39:45 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:39:39:39:68 | [TupleTypeExpr] [number ... mber[]] | tst.ts:39:40:39:45 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:39:39:39:68 | [TupleTypeExpr] [number ... mber[]] | tst.ts:39:48:39:54 | [OptionalTypeExpr] string? | semmle.label | 2 | -| tst.ts:39:39:39:68 | [TupleTypeExpr] [number ... mber[]] | tst.ts:39:48:39:54 | [OptionalTypeExpr] string? | semmle.order | 2 | -| tst.ts:39:39:39:68 | [TupleTypeExpr] [number ... mber[]] | tst.ts:39:57:39:67 | [RestTypeExpr] ...number[] | semmle.label | 3 | -| tst.ts:39:39:39:68 | [TupleTypeExpr] [number ... mber[]] | tst.ts:39:57:39:67 | [RestTypeExpr] ...number[] | semmle.order | 3 | -| tst.ts:39:48:39:54 | [OptionalTypeExpr] string? | tst.ts:39:48:39:53 | [KeywordTypeExpr] string | semmle.label | 1 | -| tst.ts:39:48:39:54 | [OptionalTypeExpr] string? | tst.ts:39:48:39:53 | [KeywordTypeExpr] string | semmle.order | 1 | -| tst.ts:39:57:39:67 | [RestTypeExpr] ...number[] | tst.ts:39:60:39:67 | [ArrayTypeExpr] number[] | semmle.label | 1 | -| tst.ts:39:57:39:67 | [RestTypeExpr] ...number[] | tst.ts:39:60:39:67 | [ArrayTypeExpr] number[] | semmle.order | 1 | -| tst.ts:39:60:39:67 | [ArrayTypeExpr] number[] | tst.ts:39:60:39:65 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:39:60:39:67 | [ArrayTypeExpr] number[] | tst.ts:39:60:39:65 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:40:1:40:25 | [DeclStmt] let unknownType = ... | tst.ts:40:5:40:24 | [VariableDeclarator] unknownType: unknown | semmle.label | 1 | -| tst.ts:40:1:40:25 | [DeclStmt] let unknownType = ... | tst.ts:40:5:40:24 | [VariableDeclarator] unknownType: unknown | semmle.order | 1 | -| tst.ts:40:5:40:24 | [VariableDeclarator] unknownType: unknown | tst.ts:40:5:40:15 | [VarDecl] unknownType | semmle.label | 1 | -| tst.ts:40:5:40:24 | [VariableDeclarator] unknownType: unknown | tst.ts:40:5:40:15 | [VarDecl] unknownType | semmle.order | 1 | -| tst.ts:40:5:40:24 | [VariableDeclarator] unknownType: unknown | tst.ts:40:18:40:24 | [KeywordTypeExpr] unknown | semmle.label | 2 | -| tst.ts:40:5:40:24 | [VariableDeclarator] unknownType: unknown | tst.ts:40:18:40:24 | [KeywordTypeExpr] unknown | semmle.order | 2 | -| tst.ts:42:1:42:40 | [DeclStmt] let constArrayLiteral = ... | tst.ts:42:5:42:39 | [VariableDeclarator] constAr ... s const | semmle.label | 1 | -| tst.ts:42:1:42:40 | [DeclStmt] let constArrayLiteral = ... | tst.ts:42:5:42:39 | [VariableDeclarator] constAr ... s const | semmle.order | 1 | -| tst.ts:42:5:42:39 | [VariableDeclarator] constAr ... s const | tst.ts:42:5:42:21 | [VarDecl] constArrayLiteral | semmle.label | 1 | -| tst.ts:42:5:42:39 | [VariableDeclarator] constAr ... s const | tst.ts:42:5:42:21 | [VarDecl] constArrayLiteral | semmle.order | 1 | -| tst.ts:42:5:42:39 | [VariableDeclarator] constAr ... s const | tst.ts:42:25:42:39 | [TypeAssertion] [1, 2] as const | semmle.label | 2 | -| tst.ts:42:5:42:39 | [VariableDeclarator] constAr ... s const | tst.ts:42:25:42:39 | [TypeAssertion] [1, 2] as const | semmle.order | 2 | -| tst.ts:42:25:42:30 | [ArrayExpr] [1, 2] | tst.ts:42:26:42:26 | [Literal] 1 | semmle.label | 1 | -| tst.ts:42:25:42:30 | [ArrayExpr] [1, 2] | tst.ts:42:26:42:26 | [Literal] 1 | semmle.order | 1 | -| tst.ts:42:25:42:30 | [ArrayExpr] [1, 2] | tst.ts:42:29:42:29 | [Literal] 2 | semmle.label | 2 | -| tst.ts:42:25:42:30 | [ArrayExpr] [1, 2] | tst.ts:42:29:42:29 | [Literal] 2 | semmle.order | 2 | -| tst.ts:42:25:42:39 | [TypeAssertion] [1, 2] as const | tst.ts:42:25:42:30 | [ArrayExpr] [1, 2] | semmle.label | 1 | -| tst.ts:42:25:42:39 | [TypeAssertion] [1, 2] as const | tst.ts:42:25:42:30 | [ArrayExpr] [1, 2] | semmle.order | 1 | -| tst.ts:42:25:42:39 | [TypeAssertion] [1, 2] as const | tst.ts:42:35:42:39 | [KeywordTypeExpr] const | semmle.label | 2 | -| tst.ts:42:25:42:39 | [TypeAssertion] [1, 2] as const | tst.ts:42:35:42:39 | [KeywordTypeExpr] const | semmle.order | 2 | -| tst.ts:43:1:43:49 | [DeclStmt] let constObjectLiteral = ... | tst.ts:43:5:43:48 | [VariableDeclarator] constOb ... s const | semmle.label | 1 | -| tst.ts:43:1:43:49 | [DeclStmt] let constObjectLiteral = ... | tst.ts:43:5:43:48 | [VariableDeclarator] constOb ... s const | semmle.order | 1 | -| tst.ts:43:5:43:48 | [VariableDeclarator] constOb ... s const | tst.ts:43:5:43:22 | [VarDecl] constObjectLiteral | semmle.label | 1 | -| tst.ts:43:5:43:48 | [VariableDeclarator] constOb ... s const | tst.ts:43:5:43:22 | [VarDecl] constObjectLiteral | semmle.order | 1 | -| tst.ts:43:5:43:48 | [VariableDeclarator] constOb ... s const | tst.ts:43:26:43:48 | [TypeAssertion] { foo: ... s const | semmle.label | 2 | -| tst.ts:43:5:43:48 | [VariableDeclarator] constOb ... s const | tst.ts:43:26:43:48 | [TypeAssertion] { foo: ... s const | semmle.order | 2 | -| tst.ts:43:26:43:39 | [ObjectExpr] {foo: ...} | tst.ts:43:28:43:37 | [Property] foo: "foo" | semmle.label | 1 | -| tst.ts:43:26:43:39 | [ObjectExpr] {foo: ...} | tst.ts:43:28:43:37 | [Property] foo: "foo" | semmle.order | 1 | -| tst.ts:43:26:43:48 | [TypeAssertion] { foo: ... s const | tst.ts:43:26:43:39 | [ObjectExpr] {foo: ...} | semmle.label | 1 | -| tst.ts:43:26:43:48 | [TypeAssertion] { foo: ... s const | tst.ts:43:26:43:39 | [ObjectExpr] {foo: ...} | semmle.order | 1 | -| tst.ts:43:26:43:48 | [TypeAssertion] { foo: ... s const | tst.ts:43:44:43:48 | [KeywordTypeExpr] const | semmle.label | 2 | -| tst.ts:43:26:43:48 | [TypeAssertion] { foo: ... s const | tst.ts:43:44:43:48 | [KeywordTypeExpr] const | semmle.order | 2 | -| tst.ts:43:28:43:37 | [Property] foo: "foo" | tst.ts:43:28:43:30 | [Label] foo | semmle.label | 1 | -| tst.ts:43:28:43:37 | [Property] foo: "foo" | tst.ts:43:28:43:30 | [Label] foo | semmle.order | 1 | -| tst.ts:43:28:43:37 | [Property] foo: "foo" | tst.ts:43:33:43:37 | [Literal] "foo" | semmle.label | 2 | -| tst.ts:43:28:43:37 | [Property] foo: "foo" | tst.ts:43:33:43:37 | [Literal] "foo" | semmle.order | 2 | -| tst.ts:46:1:51:1 | [TryStmt] try { } ... ; } } | tst.ts:46:5:46:7 | [BlockStmt] { } | semmle.label | 1 | -| tst.ts:46:1:51:1 | [TryStmt] try { } ... ; } } | tst.ts:46:5:46:7 | [BlockStmt] { } | semmle.order | 1 | -| tst.ts:46:1:51:1 | [TryStmt] try { } ... ; } } | tst.ts:47:1:51:1 | [CatchClause] catch ( ... ; } } | semmle.label | 2 | -| tst.ts:46:1:51:1 | [TryStmt] try { } ... ; } } | tst.ts:47:1:51:1 | [CatchClause] catch ( ... ; } } | semmle.order | 2 | -| tst.ts:47:1:51:1 | [CatchClause] catch ( ... ; } } | tst.ts:47:8:47:8 | [SimpleParameter] e | semmle.label | 1 | -| tst.ts:47:1:51:1 | [CatchClause] catch ( ... ; } } | tst.ts:47:8:47:8 | [SimpleParameter] e | semmle.order | 1 | -| tst.ts:47:1:51:1 | [CatchClause] catch ( ... ; } } | tst.ts:47:20:51:1 | [BlockStmt] { if ... ; } } | semmle.label | 2 | -| tst.ts:47:1:51:1 | [CatchClause] catch ( ... ; } } | tst.ts:47:20:51:1 | [BlockStmt] { if ... ; } } | semmle.order | 2 | -| tst.ts:47:20:51:1 | [BlockStmt] { if ... ; } } | tst.ts:48:3:50:3 | [IfStmt] if (typ ... e; } | semmle.label | 1 | -| tst.ts:47:20:51:1 | [BlockStmt] { if ... ; } } | tst.ts:48:3:50:3 | [IfStmt] if (typ ... e; } | semmle.order | 1 | -| tst.ts:48:3:50:3 | [IfStmt] if (typ ... e; } | tst.ts:48:7:48:27 | [BinaryExpr] typeof ... string" | semmle.label | 1 | -| tst.ts:48:3:50:3 | [IfStmt] if (typ ... e; } | tst.ts:48:7:48:27 | [BinaryExpr] typeof ... string" | semmle.order | 1 | -| tst.ts:48:3:50:3 | [IfStmt] if (typ ... e; } | tst.ts:48:30:50:3 | [BlockStmt] { ... e; } | semmle.label | 2 | -| tst.ts:48:3:50:3 | [IfStmt] if (typ ... e; } | tst.ts:48:30:50:3 | [BlockStmt] { ... e; } | semmle.order | 2 | -| tst.ts:48:7:48:14 | [UnaryExpr] typeof e | tst.ts:48:14:48:14 | [VarRef] e | semmle.label | 1 | -| tst.ts:48:7:48:14 | [UnaryExpr] typeof e | tst.ts:48:14:48:14 | [VarRef] e | semmle.order | 1 | -| tst.ts:48:7:48:27 | [BinaryExpr] typeof ... string" | tst.ts:48:7:48:14 | [UnaryExpr] typeof e | semmle.label | 1 | -| tst.ts:48:7:48:27 | [BinaryExpr] typeof ... string" | tst.ts:48:7:48:14 | [UnaryExpr] typeof e | semmle.order | 1 | -| tst.ts:48:7:48:27 | [BinaryExpr] typeof ... string" | tst.ts:48:20:48:27 | [Literal] "string" | semmle.label | 2 | -| tst.ts:48:7:48:27 | [BinaryExpr] typeof ... string" | tst.ts:48:20:48:27 | [Literal] "string" | semmle.order | 2 | -| tst.ts:48:30:50:3 | [BlockStmt] { ... e; } | tst.ts:49:7:49:25 | [DeclStmt] let b = ... | semmle.label | 1 | -| tst.ts:48:30:50:3 | [BlockStmt] { ... e; } | tst.ts:49:7:49:25 | [DeclStmt] let b = ... | semmle.order | 1 | -| tst.ts:49:7:49:25 | [DeclStmt] let b = ... | tst.ts:49:11:49:24 | [VariableDeclarator] b : string = e | semmle.label | 1 | -| tst.ts:49:7:49:25 | [DeclStmt] let b = ... | tst.ts:49:11:49:24 | [VariableDeclarator] b : string = e | semmle.order | 1 | -| tst.ts:49:11:49:24 | [VariableDeclarator] b : string = e | tst.ts:49:11:49:11 | [VarDecl] b | semmle.label | 1 | -| tst.ts:49:11:49:24 | [VariableDeclarator] b : string = e | tst.ts:49:11:49:11 | [VarDecl] b | semmle.order | 1 | -| tst.ts:49:11:49:24 | [VariableDeclarator] b : string = e | tst.ts:49:15:49:20 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:49:11:49:24 | [VariableDeclarator] b : string = e | tst.ts:49:15:49:20 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:49:11:49:24 | [VariableDeclarator] b : string = e | tst.ts:49:24:49:24 | [VarRef] e | semmle.label | 3 | -| tst.ts:49:11:49:24 | [VariableDeclarator] b : string = e | tst.ts:49:24:49:24 | [VarRef] e | semmle.order | 3 | -| tst.ts:54:1:56:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | tst.ts:54:11:54:26 | [Identifier] NonAbstractDummy | semmle.label | 1 | -| tst.ts:54:1:56:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | tst.ts:54:11:54:26 | [Identifier] NonAbstractDummy | semmle.order | 1 | -| tst.ts:54:1:56:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | tst.ts:55:3:55:20 | [MethodSignature] getArea(): number; | semmle.label | 2 | -| tst.ts:54:1:56:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | tst.ts:55:3:55:20 | [MethodSignature] getArea(): number; | semmle.order | 2 | -| tst.ts:55:3:55:20 | [FunctionExpr] getArea(): number; | tst.ts:55:14:55:19 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:55:3:55:20 | [FunctionExpr] getArea(): number; | tst.ts:55:14:55:19 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:55:3:55:20 | [MethodSignature] getArea(): number; | tst.ts:55:3:55:9 | [Label] getArea | semmle.label | 1 | -| tst.ts:55:3:55:20 | [MethodSignature] getArea(): number; | tst.ts:55:3:55:9 | [Label] getArea | semmle.order | 1 | -| tst.ts:55:3:55:20 | [MethodSignature] getArea(): number; | tst.ts:55:3:55:20 | [FunctionExpr] getArea(): number; | semmle.label | 2 | -| tst.ts:55:3:55:20 | [MethodSignature] getArea(): number; | tst.ts:55:3:55:20 | [FunctionExpr] getArea(): number; | semmle.order | 2 | -| tst.ts:58:1:60:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | tst.ts:58:11:58:17 | [Identifier] HasArea | semmle.label | 1 | -| tst.ts:58:1:60:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | tst.ts:58:11:58:17 | [Identifier] HasArea | semmle.order | 1 | -| tst.ts:58:1:60:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | tst.ts:59:3:59:20 | [MethodSignature] getArea(): number; | semmle.label | 2 | -| tst.ts:58:1:60:1 | [InterfaceDeclaration,TypeDefinition] interfa ... mber; } | tst.ts:59:3:59:20 | [MethodSignature] getArea(): number; | semmle.order | 2 | -| tst.ts:59:3:59:20 | [FunctionExpr] getArea(): number; | tst.ts:59:14:59:19 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:59:3:59:20 | [FunctionExpr] getArea(): number; | tst.ts:59:14:59:19 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:59:3:59:20 | [MethodSignature] getArea(): number; | tst.ts:59:3:59:9 | [Label] getArea | semmle.label | 1 | -| tst.ts:59:3:59:20 | [MethodSignature] getArea(): number; | tst.ts:59:3:59:9 | [Label] getArea | semmle.order | 1 | -| tst.ts:59:3:59:20 | [MethodSignature] getArea(): number; | tst.ts:59:3:59:20 | [FunctionExpr] getArea(): number; | semmle.label | 2 | -| tst.ts:59:3:59:20 | [MethodSignature] getArea(): number; | tst.ts:59:3:59:20 | [FunctionExpr] getArea(): number; | semmle.order | 2 | -| tst.ts:63:1:63:45 | [DeclStmt] let Ctor = ... | tst.ts:63:5:63:44 | [VariableDeclarator] Ctor: a ... = Shape | semmle.label | 1 | -| tst.ts:63:1:63:45 | [DeclStmt] let Ctor = ... | tst.ts:63:5:63:44 | [VariableDeclarator] Ctor: a ... = Shape | semmle.order | 1 | -| tst.ts:63:5:63:44 | [VariableDeclarator] Ctor: a ... = Shape | tst.ts:63:5:63:8 | [VarDecl] Ctor | semmle.label | 1 | -| tst.ts:63:5:63:44 | [VariableDeclarator] Ctor: a ... = Shape | tst.ts:63:5:63:8 | [VarDecl] Ctor | semmle.order | 1 | -| tst.ts:63:5:63:44 | [VariableDeclarator] Ctor: a ... = Shape | tst.ts:63:11:63:36 | [FunctionTypeExpr] abstrac ... HasArea | semmle.label | 2 | -| tst.ts:63:5:63:44 | [VariableDeclarator] Ctor: a ... = Shape | tst.ts:63:11:63:36 | [FunctionTypeExpr] abstrac ... HasArea | semmle.order | 2 | -| tst.ts:63:5:63:44 | [VariableDeclarator] Ctor: a ... = Shape | tst.ts:63:40:63:44 | [VarRef] Shape | semmle.label | 3 | -| tst.ts:63:5:63:44 | [VariableDeclarator] Ctor: a ... = Shape | tst.ts:63:40:63:44 | [VarRef] Shape | semmle.order | 3 | -| tst.ts:63:11:63:36 | [FunctionExpr] abstrac ... HasArea | tst.ts:63:30:63:36 | [LocalTypeAccess] HasArea | semmle.label | 4 | -| tst.ts:63:11:63:36 | [FunctionExpr] abstrac ... HasArea | tst.ts:63:30:63:36 | [LocalTypeAccess] HasArea | semmle.order | 4 | -| tst.ts:63:11:63:36 | [FunctionTypeExpr] abstrac ... HasArea | tst.ts:63:11:63:36 | [FunctionExpr] abstrac ... HasArea | semmle.label | 1 | -| tst.ts:63:11:63:36 | [FunctionTypeExpr] abstrac ... HasArea | tst.ts:63:11:63:36 | [FunctionExpr] abstrac ... HasArea | semmle.order | 1 | -| tst.ts:65:1:65:54 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | tst.ts:65:6:65:12 | [Identifier] MyUnion | semmle.label | 1 | -| tst.ts:65:1:65:54 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | tst.ts:65:6:65:12 | [Identifier] MyUnion | semmle.order | 1 | -| tst.ts:65:1:65:54 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | tst.ts:65:16:65:53 | [UnionTypeExpr] {myUnio ... : true} | semmle.label | 2 | -| tst.ts:65:1:65:54 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | tst.ts:65:16:65:53 | [UnionTypeExpr] {myUnio ... : true} | semmle.order | 2 | -| tst.ts:65:16:65:30 | [InterfaceTypeExpr] {myUnion: true} | tst.ts:65:17:65:29 | [FieldDeclaration] myUnion: true | semmle.label | 1 | -| tst.ts:65:16:65:30 | [InterfaceTypeExpr] {myUnion: true} | tst.ts:65:17:65:29 | [FieldDeclaration] myUnion: true | semmle.order | 1 | -| tst.ts:65:16:65:53 | [UnionTypeExpr] {myUnio ... : true} | tst.ts:65:16:65:30 | [InterfaceTypeExpr] {myUnion: true} | semmle.label | 1 | -| tst.ts:65:16:65:53 | [UnionTypeExpr] {myUnio ... : true} | tst.ts:65:16:65:30 | [InterfaceTypeExpr] {myUnion: true} | semmle.order | 1 | -| tst.ts:65:16:65:53 | [UnionTypeExpr] {myUnio ... : true} | tst.ts:65:34:65:53 | [InterfaceTypeExpr] {stillMyUnion: true} | semmle.label | 2 | -| tst.ts:65:16:65:53 | [UnionTypeExpr] {myUnio ... : true} | tst.ts:65:34:65:53 | [InterfaceTypeExpr] {stillMyUnion: true} | semmle.order | 2 | -| tst.ts:65:17:65:29 | [FieldDeclaration] myUnion: true | tst.ts:65:17:65:23 | [Label] myUnion | semmle.label | 1 | -| tst.ts:65:17:65:29 | [FieldDeclaration] myUnion: true | tst.ts:65:17:65:23 | [Label] myUnion | semmle.order | 1 | -| tst.ts:65:17:65:29 | [FieldDeclaration] myUnion: true | tst.ts:65:26:65:29 | [LiteralTypeExpr] true | semmle.label | 2 | -| tst.ts:65:17:65:29 | [FieldDeclaration] myUnion: true | tst.ts:65:26:65:29 | [LiteralTypeExpr] true | semmle.order | 2 | -| tst.ts:65:34:65:53 | [InterfaceTypeExpr] {stillMyUnion: true} | tst.ts:65:35:65:52 | [FieldDeclaration] stillMyUnion: true | semmle.label | 1 | -| tst.ts:65:34:65:53 | [InterfaceTypeExpr] {stillMyUnion: true} | tst.ts:65:35:65:52 | [FieldDeclaration] stillMyUnion: true | semmle.order | 1 | -| tst.ts:65:35:65:52 | [FieldDeclaration] stillMyUnion: true | tst.ts:65:35:65:46 | [Label] stillMyUnion | semmle.label | 1 | -| tst.ts:65:35:65:52 | [FieldDeclaration] stillMyUnion: true | tst.ts:65:35:65:46 | [Label] stillMyUnion | semmle.order | 1 | -| tst.ts:65:35:65:52 | [FieldDeclaration] stillMyUnion: true | tst.ts:65:49:65:52 | [LiteralTypeExpr] true | semmle.label | 2 | -| tst.ts:65:35:65:52 | [FieldDeclaration] stillMyUnion: true | tst.ts:65:49:65:52 | [LiteralTypeExpr] true | semmle.order | 2 | -| tst.ts:66:1:66:38 | [DeclStmt] let union1 = ... | tst.ts:66:5:66:37 | [VariableDeclarator] union1: ... : true} | semmle.label | 1 | -| tst.ts:66:1:66:38 | [DeclStmt] let union1 = ... | tst.ts:66:5:66:37 | [VariableDeclarator] union1: ... : true} | semmle.order | 1 | -| tst.ts:66:5:66:37 | [VariableDeclarator] union1: ... : true} | tst.ts:66:5:66:10 | [VarDecl] union1 | semmle.label | 1 | -| tst.ts:66:5:66:37 | [VariableDeclarator] union1: ... : true} | tst.ts:66:5:66:10 | [VarDecl] union1 | semmle.order | 1 | -| tst.ts:66:5:66:37 | [VariableDeclarator] union1: ... : true} | tst.ts:66:13:66:19 | [LocalTypeAccess] MyUnion | semmle.label | 2 | -| tst.ts:66:5:66:37 | [VariableDeclarator] union1: ... : true} | tst.ts:66:13:66:19 | [LocalTypeAccess] MyUnion | semmle.order | 2 | -| tst.ts:66:5:66:37 | [VariableDeclarator] union1: ... : true} | tst.ts:66:23:66:37 | [ObjectExpr] {myUnion: ...} | semmle.label | 3 | -| tst.ts:66:5:66:37 | [VariableDeclarator] union1: ... : true} | tst.ts:66:23:66:37 | [ObjectExpr] {myUnion: ...} | semmle.order | 3 | -| tst.ts:66:23:66:37 | [ObjectExpr] {myUnion: ...} | tst.ts:66:24:66:36 | [Property] myUnion: true | semmle.label | 1 | -| tst.ts:66:23:66:37 | [ObjectExpr] {myUnion: ...} | tst.ts:66:24:66:36 | [Property] myUnion: true | semmle.order | 1 | -| tst.ts:66:24:66:36 | [Property] myUnion: true | tst.ts:66:24:66:30 | [Label] myUnion | semmle.label | 1 | -| tst.ts:66:24:66:36 | [Property] myUnion: true | tst.ts:66:24:66:30 | [Label] myUnion | semmle.order | 1 | -| tst.ts:66:24:66:36 | [Property] myUnion: true | tst.ts:66:33:66:36 | [Literal] true | semmle.label | 2 | -| tst.ts:66:24:66:36 | [Property] myUnion: true | tst.ts:66:33:66:36 | [Literal] true | semmle.order | 2 | -| tst.ts:68:1:68:49 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | tst.ts:68:6:68:13 | [Identifier] MyUnion2 | semmle.label | 1 | -| tst.ts:68:1:68:49 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | tst.ts:68:6:68:13 | [Identifier] MyUnion2 | semmle.order | 1 | -| tst.ts:68:1:68:49 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | tst.ts:68:17:68:48 | [UnionTypeExpr] MyUnion ... : true} | semmle.label | 2 | -| tst.ts:68:1:68:49 | [TypeAliasDeclaration,TypeDefinition] type My ... true}; | tst.ts:68:17:68:48 | [UnionTypeExpr] MyUnion ... : true} | semmle.order | 2 | -| tst.ts:68:17:68:48 | [UnionTypeExpr] MyUnion ... : true} | tst.ts:68:17:68:23 | [LocalTypeAccess] MyUnion | semmle.label | 1 | -| tst.ts:68:17:68:48 | [UnionTypeExpr] MyUnion ... : true} | tst.ts:68:17:68:23 | [LocalTypeAccess] MyUnion | semmle.order | 1 | -| tst.ts:68:17:68:48 | [UnionTypeExpr] MyUnion ... : true} | tst.ts:68:27:68:48 | [InterfaceTypeExpr] {yetAno ... : true} | semmle.label | 2 | -| tst.ts:68:17:68:48 | [UnionTypeExpr] MyUnion ... : true} | tst.ts:68:27:68:48 | [InterfaceTypeExpr] {yetAno ... : true} | semmle.order | 2 | -| tst.ts:68:27:68:48 | [InterfaceTypeExpr] {yetAno ... : true} | tst.ts:68:28:68:47 | [FieldDeclaration] yetAnotherType: true | semmle.label | 1 | -| tst.ts:68:27:68:48 | [InterfaceTypeExpr] {yetAno ... : true} | tst.ts:68:28:68:47 | [FieldDeclaration] yetAnotherType: true | semmle.order | 1 | -| tst.ts:68:28:68:47 | [FieldDeclaration] yetAnotherType: true | tst.ts:68:28:68:41 | [Label] yetAnotherType | semmle.label | 1 | -| tst.ts:68:28:68:47 | [FieldDeclaration] yetAnotherType: true | tst.ts:68:28:68:41 | [Label] yetAnotherType | semmle.order | 1 | -| tst.ts:68:28:68:47 | [FieldDeclaration] yetAnotherType: true | tst.ts:68:44:68:47 | [LiteralTypeExpr] true | semmle.label | 2 | -| tst.ts:68:28:68:47 | [FieldDeclaration] yetAnotherType: true | tst.ts:68:44:68:47 | [LiteralTypeExpr] true | semmle.order | 2 | -| tst.ts:69:1:69:46 | [DeclStmt] let union2 = ... | tst.ts:69:5:69:45 | [VariableDeclarator] union2: ... : true} | semmle.label | 1 | -| tst.ts:69:1:69:46 | [DeclStmt] let union2 = ... | tst.ts:69:5:69:45 | [VariableDeclarator] union2: ... : true} | semmle.order | 1 | -| tst.ts:69:5:69:45 | [VariableDeclarator] union2: ... : true} | tst.ts:69:5:69:10 | [VarDecl] union2 | semmle.label | 1 | -| tst.ts:69:5:69:45 | [VariableDeclarator] union2: ... : true} | tst.ts:69:5:69:10 | [VarDecl] union2 | semmle.order | 1 | -| tst.ts:69:5:69:45 | [VariableDeclarator] union2: ... : true} | tst.ts:69:13:69:20 | [LocalTypeAccess] MyUnion2 | semmle.label | 2 | -| tst.ts:69:5:69:45 | [VariableDeclarator] union2: ... : true} | tst.ts:69:13:69:20 | [LocalTypeAccess] MyUnion2 | semmle.order | 2 | -| tst.ts:69:5:69:45 | [VariableDeclarator] union2: ... : true} | tst.ts:69:24:69:45 | [ObjectExpr] {yetAnotherType: ...} | semmle.label | 3 | -| tst.ts:69:5:69:45 | [VariableDeclarator] union2: ... : true} | tst.ts:69:24:69:45 | [ObjectExpr] {yetAnotherType: ...} | semmle.order | 3 | -| tst.ts:69:24:69:45 | [ObjectExpr] {yetAnotherType: ...} | tst.ts:69:25:69:44 | [Property] yetAnotherType: true | semmle.label | 1 | -| tst.ts:69:24:69:45 | [ObjectExpr] {yetAnotherType: ...} | tst.ts:69:25:69:44 | [Property] yetAnotherType: true | semmle.order | 1 | -| tst.ts:69:25:69:44 | [Property] yetAnotherType: true | tst.ts:69:25:69:38 | [Label] yetAnotherType | semmle.label | 1 | -| tst.ts:69:25:69:44 | [Property] yetAnotherType: true | tst.ts:69:25:69:38 | [Label] yetAnotherType | semmle.order | 1 | -| tst.ts:69:25:69:44 | [Property] yetAnotherType: true | tst.ts:69:41:69:44 | [Literal] true | semmle.label | 2 | -| tst.ts:69:25:69:44 | [Property] yetAnotherType: true | tst.ts:69:41:69:44 | [Literal] true | semmle.order | 2 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:71:8:71:11 | [VarDecl] TS43 | semmle.label | 1 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:71:8:71:11 | [VarDecl] TS43 | semmle.order | 1 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:73:3:76:3 | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | semmle.label | 2 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:73:3:76:3 | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | semmle.order | 2 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:78:3:88:3 | [ExportDeclaration] export ... } } | semmle.label | 3 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:78:3:88:3 | [ExportDeclaration] export ... } } | semmle.order | 3 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:91:3:95:3 | [ClassDefinition,TypeDefinition] class S ... } } | semmle.label | 4 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:91:3:95:3 | [ClassDefinition,TypeDefinition] class S ... } } | semmle.order | 4 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | semmle.label | 5 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | semmle.order | 5 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | semmle.label | 6 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | semmle.order | 6 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:109:3:109:50 | [DeclStmt] let s1 = ... | semmle.label | 7 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:109:3:109:50 | [DeclStmt] let s1 = ... | semmle.order | 7 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:110:3:110:26 | [DeclStmt] let s2 = ... | semmle.label | 8 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:110:3:110:26 | [DeclStmt] let s2 = ... | semmle.order | 8 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:111:3:111:34 | [DeclStmt] let s3 = ... | semmle.label | 9 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:111:3:111:34 | [DeclStmt] let s3 = ... | semmle.order | 9 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:112:3:112:10 | [ExprStmt] s1 = s2; | semmle.label | 10 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:112:3:112:10 | [ExprStmt] s1 = s2; | semmle.order | 10 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:113:3:113:10 | [ExprStmt] s1 = s3; | semmle.label | 11 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:113:3:113:10 | [ExprStmt] s1 = s3; | semmle.order | 11 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | semmle.label | 12 | -| tst.ts:71:1:130:1 | [NamespaceDeclaration] module ... } } | tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | semmle.order | 12 | -| tst.ts:73:3:76:3 | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | tst.ts:73:13:73:18 | [Identifier] ThingI | semmle.label | 1 | -| tst.ts:73:3:76:3 | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | tst.ts:73:13:73:18 | [Identifier] ThingI | semmle.order | 1 | -| tst.ts:73:3:76:3 | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | tst.ts:74:5:74:22 | [GetterMethodSignature] get size(): number | semmle.label | 2 | -| tst.ts:73:3:76:3 | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | tst.ts:74:5:74:22 | [GetterMethodSignature] get size(): number | semmle.order | 2 | -| tst.ts:73:3:76:3 | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | tst.ts:75:5:75:47 | [SetterMethodSignature] set siz ... olean); | semmle.label | 3 | -| tst.ts:73:3:76:3 | [InterfaceDeclaration,TypeDefinition] interfa ... n); } | tst.ts:75:5:75:47 | [SetterMethodSignature] set siz ... olean); | semmle.order | 3 | -| tst.ts:74:5:74:22 | [FunctionExpr] get size(): number | tst.ts:74:17:74:22 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:74:5:74:22 | [FunctionExpr] get size(): number | tst.ts:74:17:74:22 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:74:5:74:22 | [GetterMethodSignature] get size(): number | tst.ts:74:5:74:22 | [FunctionExpr] get size(): number | semmle.label | 1 | -| tst.ts:74:5:74:22 | [GetterMethodSignature] get size(): number | tst.ts:74:5:74:22 | [FunctionExpr] get size(): number | semmle.order | 1 | -| tst.ts:74:5:74:22 | [GetterMethodSignature] get size(): number | tst.ts:74:9:74:12 | [Label] size | semmle.label | 2 | -| tst.ts:74:5:74:22 | [GetterMethodSignature] get size(): number | tst.ts:74:9:74:12 | [Label] size | semmle.order | 2 | -| tst.ts:75:5:75:47 | [FunctionExpr] set siz ... olean); | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:75:5:75:47 | [FunctionExpr] set siz ... olean); | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:75:5:75:47 | [SetterMethodSignature] set siz ... olean); | tst.ts:75:5:75:47 | [FunctionExpr] set siz ... olean); | semmle.label | 1 | -| tst.ts:75:5:75:47 | [SetterMethodSignature] set siz ... olean); | tst.ts:75:5:75:47 | [FunctionExpr] set siz ... olean); | semmle.order | 1 | -| tst.ts:75:5:75:47 | [SetterMethodSignature] set siz ... olean); | tst.ts:75:9:75:12 | [Label] size | semmle.label | 2 | -| tst.ts:75:5:75:47 | [SetterMethodSignature] set siz ... olean); | tst.ts:75:9:75:12 | [Label] size | semmle.order | 2 | -| tst.ts:75:14:75:18 | [SimpleParameter] value | tst.ts:75:21:75:45 | [UnionTypeExpr] number ... boolean | semmle.label | -2 | -| tst.ts:75:14:75:18 | [SimpleParameter] value | tst.ts:75:21:75:45 | [UnionTypeExpr] number ... boolean | semmle.order | -2 | -| tst.ts:75:21:75:45 | [UnionTypeExpr] number ... boolean | tst.ts:75:21:75:26 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:75:21:75:45 | [UnionTypeExpr] number ... boolean | tst.ts:75:21:75:26 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:75:21:75:45 | [UnionTypeExpr] number ... boolean | tst.ts:75:30:75:35 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:75:21:75:45 | [UnionTypeExpr] number ... boolean | tst.ts:75:30:75:35 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:75:21:75:45 | [UnionTypeExpr] number ... boolean | tst.ts:75:39:75:45 | [KeywordTypeExpr] boolean | semmle.label | 3 | -| tst.ts:75:21:75:45 | [UnionTypeExpr] number ... boolean | tst.ts:75:39:75:45 | [KeywordTypeExpr] boolean | semmle.order | 3 | -| tst.ts:78:3:88:3 | [ExportDeclaration] export ... } } | tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | semmle.label | 1 | -| tst.ts:78:3:88:3 | [ExportDeclaration] export ... } } | tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | semmle.order | 1 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:78:16:78:20 | [VarDecl] Thing | semmle.label | 1 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:78:16:78:20 | [VarDecl] Thing | semmle.order | 1 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:78:33:78:38 | [LocalTypeAccess] ThingI | semmle.label | 2 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:78:33:78:38 | [LocalTypeAccess] ThingI | semmle.order | 2 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:78:40:78:39 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | 3 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:78:40:78:39 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.order | 3 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:79:5:79:14 | [FieldDeclaration] #size = 0; | semmle.label | 4 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:79:5:79:14 | [FieldDeclaration] #size = 0; | semmle.order | 4 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:81:5:83:5 | [ClassInitializedMember,GetterMethodDefinition] get siz ... ; } | semmle.label | 5 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:81:5:83:5 | [ClassInitializedMember,GetterMethodDefinition] get siz ... ; } | semmle.order | 5 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:85:5:87:5 | [ClassInitializedMember,SetterMethodDefinition] set siz ... ; } | semmle.label | 6 | -| tst.ts:78:10:88:3 | [ClassDefinition,TypeDefinition] class T ... } } | tst.ts:85:5:87:5 | [ClassInitializedMember,SetterMethodDefinition] set siz ... ; } | semmle.order | 6 | -| tst.ts:78:40:78:39 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:78:40:78:39 | [FunctionExpr] () {} | semmle.label | 2 | -| tst.ts:78:40:78:39 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:78:40:78:39 | [FunctionExpr] () {} | semmle.order | 2 | -| tst.ts:78:40:78:39 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:78:40:78:39 | [Label] constructor | semmle.label | 1 | -| tst.ts:78:40:78:39 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:78:40:78:39 | [Label] constructor | semmle.order | 1 | -| tst.ts:78:40:78:39 | [FunctionExpr] () {} | tst.ts:78:40:78:39 | [BlockStmt] {} | semmle.label | 5 | -| tst.ts:78:40:78:39 | [FunctionExpr] () {} | tst.ts:78:40:78:39 | [BlockStmt] {} | semmle.order | 5 | -| tst.ts:79:5:79:14 | [FieldDeclaration] #size = 0; | tst.ts:79:5:79:9 | [Label] #size | semmle.label | 1 | -| tst.ts:79:5:79:14 | [FieldDeclaration] #size = 0; | tst.ts:79:5:79:9 | [Label] #size | semmle.order | 1 | -| tst.ts:79:5:79:14 | [FieldDeclaration] #size = 0; | tst.ts:79:13:79:13 | [Literal] 0 | semmle.label | 2 | -| tst.ts:79:5:79:14 | [FieldDeclaration] #size = 0; | tst.ts:79:13:79:13 | [Literal] 0 | semmle.order | 2 | -| tst.ts:81:5:83:5 | [ClassInitializedMember,GetterMethodDefinition] get siz ... ; } | tst.ts:81:5:83:5 | [FunctionExpr] get siz ... ; } | semmle.label | 1 | -| tst.ts:81:5:83:5 | [ClassInitializedMember,GetterMethodDefinition] get siz ... ; } | tst.ts:81:5:83:5 | [FunctionExpr] get siz ... ; } | semmle.order | 1 | -| tst.ts:81:5:83:5 | [ClassInitializedMember,GetterMethodDefinition] get siz ... ; } | tst.ts:81:9:81:12 | [Label] size | semmle.label | 2 | -| tst.ts:81:5:83:5 | [ClassInitializedMember,GetterMethodDefinition] get siz ... ; } | tst.ts:81:9:81:12 | [Label] size | semmle.order | 2 | -| tst.ts:81:5:83:5 | [FunctionExpr] get siz ... ; } | tst.ts:81:17:81:22 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:81:5:83:5 | [FunctionExpr] get siz ... ; } | tst.ts:81:17:81:22 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:81:5:83:5 | [FunctionExpr] get siz ... ; } | tst.ts:81:24:83:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:81:5:83:5 | [FunctionExpr] get siz ... ; } | tst.ts:81:24:83:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:81:24:83:5 | [BlockStmt] { ... ; } | tst.ts:82:7:82:24 | [ReturnStmt] return this.#size; | semmle.label | 1 | -| tst.ts:81:24:83:5 | [BlockStmt] { ... ; } | tst.ts:82:7:82:24 | [ReturnStmt] return this.#size; | semmle.order | 1 | -| tst.ts:82:7:82:24 | [ReturnStmt] return this.#size; | tst.ts:82:14:82:23 | [DotExpr] this.#size | semmle.label | 1 | -| tst.ts:82:7:82:24 | [ReturnStmt] return this.#size; | tst.ts:82:14:82:23 | [DotExpr] this.#size | semmle.order | 1 | -| tst.ts:82:14:82:23 | [DotExpr] this.#size | tst.ts:82:14:82:17 | [ThisExpr] this | semmle.label | 1 | -| tst.ts:82:14:82:23 | [DotExpr] this.#size | tst.ts:82:14:82:17 | [ThisExpr] this | semmle.order | 1 | -| tst.ts:82:14:82:23 | [DotExpr] this.#size | tst.ts:82:19:82:23 | [Label] #size | semmle.label | 2 | -| tst.ts:82:14:82:23 | [DotExpr] this.#size | tst.ts:82:19:82:23 | [Label] #size | semmle.order | 2 | -| tst.ts:85:5:87:5 | [ClassInitializedMember,SetterMethodDefinition] set siz ... ; } | tst.ts:85:5:87:5 | [FunctionExpr] set siz ... ; } | semmle.label | 1 | -| tst.ts:85:5:87:5 | [ClassInitializedMember,SetterMethodDefinition] set siz ... ; } | tst.ts:85:5:87:5 | [FunctionExpr] set siz ... ; } | semmle.order | 1 | -| tst.ts:85:5:87:5 | [ClassInitializedMember,SetterMethodDefinition] set siz ... ; } | tst.ts:85:9:85:12 | [Label] size | semmle.label | 2 | -| tst.ts:85:5:87:5 | [ClassInitializedMember,SetterMethodDefinition] set siz ... ; } | tst.ts:85:9:85:12 | [Label] size | semmle.order | 2 | -| tst.ts:85:5:87:5 | [FunctionExpr] set siz ... ; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:85:5:87:5 | [FunctionExpr] set siz ... ; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:85:5:87:5 | [FunctionExpr] set siz ... ; } | tst.ts:85:48:87:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:85:5:87:5 | [FunctionExpr] set siz ... ; } | tst.ts:85:48:87:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:85:14:85:18 | [SimpleParameter] value | tst.ts:85:21:85:45 | [UnionTypeExpr] string ... boolean | semmle.label | -2 | -| tst.ts:85:14:85:18 | [SimpleParameter] value | tst.ts:85:21:85:45 | [UnionTypeExpr] string ... boolean | semmle.order | -2 | -| tst.ts:85:21:85:45 | [UnionTypeExpr] string ... boolean | tst.ts:85:21:85:26 | [KeywordTypeExpr] string | semmle.label | 1 | -| tst.ts:85:21:85:45 | [UnionTypeExpr] string ... boolean | tst.ts:85:21:85:26 | [KeywordTypeExpr] string | semmle.order | 1 | -| tst.ts:85:21:85:45 | [UnionTypeExpr] string ... boolean | tst.ts:85:30:85:35 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:85:21:85:45 | [UnionTypeExpr] string ... boolean | tst.ts:85:30:85:35 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:85:21:85:45 | [UnionTypeExpr] string ... boolean | tst.ts:85:39:85:45 | [KeywordTypeExpr] boolean | semmle.label | 3 | -| tst.ts:85:21:85:45 | [UnionTypeExpr] string ... boolean | tst.ts:85:39:85:45 | [KeywordTypeExpr] boolean | semmle.order | 3 | -| tst.ts:85:48:87:5 | [BlockStmt] { ... ; } | tst.ts:86:7:86:33 | [ExprStmt] this.#s ... value); | semmle.label | 1 | -| tst.ts:85:48:87:5 | [BlockStmt] { ... ; } | tst.ts:86:7:86:33 | [ExprStmt] this.#s ... value); | semmle.order | 1 | -| tst.ts:86:7:86:16 | [DotExpr] this.#size | tst.ts:86:7:86:10 | [ThisExpr] this | semmle.label | 1 | -| tst.ts:86:7:86:16 | [DotExpr] this.#size | tst.ts:86:7:86:10 | [ThisExpr] this | semmle.order | 1 | -| tst.ts:86:7:86:16 | [DotExpr] this.#size | tst.ts:86:12:86:16 | [Label] #size | semmle.label | 2 | -| tst.ts:86:7:86:16 | [DotExpr] this.#size | tst.ts:86:12:86:16 | [Label] #size | semmle.order | 2 | -| tst.ts:86:7:86:32 | [AssignExpr] this.#s ... (value) | tst.ts:86:7:86:16 | [DotExpr] this.#size | semmle.label | 1 | -| tst.ts:86:7:86:32 | [AssignExpr] this.#s ... (value) | tst.ts:86:7:86:16 | [DotExpr] this.#size | semmle.order | 1 | -| tst.ts:86:7:86:32 | [AssignExpr] this.#s ... (value) | tst.ts:86:20:86:32 | [CallExpr] Number(value) | semmle.label | 2 | -| tst.ts:86:7:86:32 | [AssignExpr] this.#s ... (value) | tst.ts:86:20:86:32 | [CallExpr] Number(value) | semmle.order | 2 | -| tst.ts:86:7:86:33 | [ExprStmt] this.#s ... value); | tst.ts:86:7:86:32 | [AssignExpr] this.#s ... (value) | semmle.label | 1 | -| tst.ts:86:7:86:33 | [ExprStmt] this.#s ... value); | tst.ts:86:7:86:32 | [AssignExpr] this.#s ... (value) | semmle.order | 1 | -| tst.ts:86:20:86:32 | [CallExpr] Number(value) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:86:20:86:32 | [CallExpr] Number(value) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:86:20:86:32 | [CallExpr] Number(value) | tst.ts:86:20:86:25 | [VarRef] Number | semmle.label | 0 | -| tst.ts:86:20:86:32 | [CallExpr] Number(value) | tst.ts:86:20:86:25 | [VarRef] Number | semmle.order | 0 | -| tst.ts:91:3:95:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:91:9:91:13 | [VarDecl] Super | semmle.label | 1 | -| tst.ts:91:3:95:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:91:9:91:13 | [VarDecl] Super | semmle.order | 1 | -| tst.ts:91:3:95:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:91:15:91:14 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | 2 | -| tst.ts:91:3:95:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:91:15:91:14 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.order | 2 | -| tst.ts:91:3:95:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:92:5:94:5 | [ClassInitializedMember,MethodDefinition] random( ... ; } | semmle.label | 3 | -| tst.ts:91:3:95:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:92:5:94:5 | [ClassInitializedMember,MethodDefinition] random( ... ; } | semmle.order | 3 | -| tst.ts:91:15:91:14 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:91:15:91:14 | [FunctionExpr] () {} | semmle.label | 2 | -| tst.ts:91:15:91:14 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:91:15:91:14 | [FunctionExpr] () {} | semmle.order | 2 | -| tst.ts:91:15:91:14 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:91:15:91:14 | [Label] constructor | semmle.label | 1 | -| tst.ts:91:15:91:14 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:91:15:91:14 | [Label] constructor | semmle.order | 1 | -| tst.ts:91:15:91:14 | [FunctionExpr] () {} | tst.ts:91:15:91:14 | [BlockStmt] {} | semmle.label | 5 | -| tst.ts:91:15:91:14 | [FunctionExpr] () {} | tst.ts:91:15:91:14 | [BlockStmt] {} | semmle.order | 5 | -| tst.ts:92:5:94:5 | [ClassInitializedMember,MethodDefinition] random( ... ; } | tst.ts:92:5:92:10 | [Label] random | semmle.label | 1 | -| tst.ts:92:5:94:5 | [ClassInitializedMember,MethodDefinition] random( ... ; } | tst.ts:92:5:92:10 | [Label] random | semmle.order | 1 | -| tst.ts:92:5:94:5 | [ClassInitializedMember,MethodDefinition] random( ... ; } | tst.ts:92:5:94:5 | [FunctionExpr] random( ... ; } | semmle.label | 2 | -| tst.ts:92:5:94:5 | [ClassInitializedMember,MethodDefinition] random( ... ; } | tst.ts:92:5:94:5 | [FunctionExpr] random( ... ; } | semmle.order | 2 | -| tst.ts:92:5:94:5 | [FunctionExpr] random( ... ; } | tst.ts:92:15:92:20 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:92:5:94:5 | [FunctionExpr] random( ... ; } | tst.ts:92:15:92:20 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:92:5:94:5 | [FunctionExpr] random( ... ; } | tst.ts:92:22:94:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:92:5:94:5 | [FunctionExpr] random( ... ; } | tst.ts:92:22:94:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:92:22:94:5 | [BlockStmt] { ... ; } | tst.ts:93:7:93:15 | [ReturnStmt] return 4; | semmle.label | 1 | -| tst.ts:92:22:94:5 | [BlockStmt] { ... ; } | tst.ts:93:7:93:15 | [ReturnStmt] return 4; | semmle.order | 1 | -| tst.ts:93:7:93:15 | [ReturnStmt] return 4; | tst.ts:93:14:93:14 | [Literal] 4 | semmle.label | 1 | -| tst.ts:93:7:93:15 | [ReturnStmt] return 4; | tst.ts:93:14:93:14 | [Literal] 4 | semmle.order | 1 | -| tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:97:9:97:11 | [VarDecl] Sub | semmle.label | 1 | -| tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:97:9:97:11 | [VarDecl] Sub | semmle.order | 1 | -| tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:97:21:97:25 | [VarRef] Super | semmle.label | 2 | -| tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:97:21:97:25 | [VarRef] Super | semmle.order | 2 | -| tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:97:27:97:26 | [ClassInitializedMember,ConstructorDefinition] constru ... rgs); } | semmle.label | 3 | -| tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:97:27:97:26 | [ClassInitializedMember,ConstructorDefinition] constru ... rgs); } | semmle.order | 3 | -| tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:98:5:100:5 | [ClassInitializedMember,MethodDefinition] overrid ... ; } | semmle.label | 4 | -| tst.ts:97:3:101:3 | [ClassDefinition,TypeDefinition] class S ... } } | tst.ts:98:5:100:5 | [ClassInitializedMember,MethodDefinition] overrid ... ; } | semmle.order | 4 | -| tst.ts:97:27:97:26 | [BlockStmt] { super(...args); } | tst.ts:97:27:97:26 | [ExprStmt] super(...args); | semmle.label | 1 | -| tst.ts:97:27:97:26 | [BlockStmt] { super(...args); } | tst.ts:97:27:97:26 | [ExprStmt] super(...args); | semmle.order | 1 | -| tst.ts:97:27:97:26 | [CallExpr] super(...args) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:97:27:97:26 | [CallExpr] super(...args) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:97:27:97:26 | [CallExpr] super(...args) | tst.ts:97:27:97:26 | [SuperExpr] super | semmle.label | 0 | -| tst.ts:97:27:97:26 | [CallExpr] super(...args) | tst.ts:97:27:97:26 | [SuperExpr] super | semmle.order | 0 | -| tst.ts:97:27:97:26 | [ClassInitializedMember,ConstructorDefinition] constru ... rgs); } | tst.ts:97:27:97:26 | [FunctionExpr] (...arg ... rgs); } | semmle.label | 2 | -| tst.ts:97:27:97:26 | [ClassInitializedMember,ConstructorDefinition] constru ... rgs); } | tst.ts:97:27:97:26 | [FunctionExpr] (...arg ... rgs); } | semmle.order | 2 | -| tst.ts:97:27:97:26 | [ClassInitializedMember,ConstructorDefinition] constru ... rgs); } | tst.ts:97:27:97:26 | [Label] constructor | semmle.label | 1 | -| tst.ts:97:27:97:26 | [ClassInitializedMember,ConstructorDefinition] constru ... rgs); } | tst.ts:97:27:97:26 | [Label] constructor | semmle.order | 1 | -| tst.ts:97:27:97:26 | [ExprStmt] super(...args); | tst.ts:97:27:97:26 | [CallExpr] super(...args) | semmle.label | 1 | -| tst.ts:97:27:97:26 | [ExprStmt] super(...args); | tst.ts:97:27:97:26 | [CallExpr] super(...args) | semmle.order | 1 | -| tst.ts:97:27:97:26 | [FunctionExpr] (...arg ... rgs); } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:97:27:97:26 | [FunctionExpr] (...arg ... rgs); } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:97:27:97:26 | [FunctionExpr] (...arg ... rgs); } | tst.ts:97:27:97:26 | [BlockStmt] { super(...args); } | semmle.label | 5 | -| tst.ts:97:27:97:26 | [FunctionExpr] (...arg ... rgs); } | tst.ts:97:27:97:26 | [BlockStmt] { super(...args); } | semmle.order | 5 | -| tst.ts:97:27:97:26 | [SpreadElement] ...args | tst.ts:97:27:97:26 | [VarRef] args | semmle.label | 1 | -| tst.ts:97:27:97:26 | [SpreadElement] ...args | tst.ts:97:27:97:26 | [VarRef] args | semmle.order | 1 | -| tst.ts:98:5:100:5 | [ClassInitializedMember,MethodDefinition] overrid ... ; } | tst.ts:98:5:100:5 | [FunctionExpr] overrid ... ; } | semmle.label | 1 | -| tst.ts:98:5:100:5 | [ClassInitializedMember,MethodDefinition] overrid ... ; } | tst.ts:98:5:100:5 | [FunctionExpr] overrid ... ; } | semmle.order | 1 | -| tst.ts:98:5:100:5 | [ClassInitializedMember,MethodDefinition] overrid ... ; } | tst.ts:98:14:98:19 | [Label] random | semmle.label | 2 | -| tst.ts:98:5:100:5 | [ClassInitializedMember,MethodDefinition] overrid ... ; } | tst.ts:98:14:98:19 | [Label] random | semmle.order | 2 | -| tst.ts:98:5:100:5 | [FunctionExpr] overrid ... ; } | tst.ts:98:24:98:29 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:98:5:100:5 | [FunctionExpr] overrid ... ; } | tst.ts:98:24:98:29 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:98:5:100:5 | [FunctionExpr] overrid ... ; } | tst.ts:98:31:100:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:98:5:100:5 | [FunctionExpr] overrid ... ; } | tst.ts:98:31:100:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:98:31:100:5 | [BlockStmt] { ... ; } | tst.ts:99:7:99:33 | [ReturnStmt] return ... ) * 10; | semmle.label | 1 | -| tst.ts:98:31:100:5 | [BlockStmt] { ... ; } | tst.ts:99:7:99:33 | [ReturnStmt] return ... ) * 10; | semmle.order | 1 | -| tst.ts:99:7:99:33 | [ReturnStmt] return ... ) * 10; | tst.ts:99:14:99:32 | [BinaryExpr] super.random() * 10 | semmle.label | 1 | -| tst.ts:99:7:99:33 | [ReturnStmt] return ... ) * 10; | tst.ts:99:14:99:32 | [BinaryExpr] super.random() * 10 | semmle.order | 1 | -| tst.ts:99:14:99:25 | [DotExpr] super.random | tst.ts:99:14:99:18 | [SuperExpr] super | semmle.label | 1 | -| tst.ts:99:14:99:25 | [DotExpr] super.random | tst.ts:99:14:99:18 | [SuperExpr] super | semmle.order | 1 | -| tst.ts:99:14:99:25 | [DotExpr] super.random | tst.ts:99:20:99:25 | [Label] random | semmle.label | 2 | -| tst.ts:99:14:99:25 | [DotExpr] super.random | tst.ts:99:20:99:25 | [Label] random | semmle.order | 2 | -| tst.ts:99:14:99:27 | [MethodCallExpr] super.random() | tst.ts:99:14:99:25 | [DotExpr] super.random | semmle.label | 0 | -| tst.ts:99:14:99:27 | [MethodCallExpr] super.random() | tst.ts:99:14:99:25 | [DotExpr] super.random | semmle.order | 0 | -| tst.ts:99:14:99:32 | [BinaryExpr] super.random() * 10 | tst.ts:99:14:99:27 | [MethodCallExpr] super.random() | semmle.label | 1 | -| tst.ts:99:14:99:32 | [BinaryExpr] super.random() * 10 | tst.ts:99:14:99:27 | [MethodCallExpr] super.random() | semmle.order | 1 | -| tst.ts:99:14:99:32 | [BinaryExpr] super.random() * 10 | tst.ts:99:31:99:32 | [Literal] 10 | semmle.label | 2 | -| tst.ts:99:14:99:32 | [BinaryExpr] super.random() * 10 | tst.ts:99:31:99:32 | [Literal] 10 | semmle.order | 2 | -| tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | tst.ts:104:12:104:14 | [VarDecl] bar | semmle.label | 0 | -| tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | tst.ts:104:12:104:14 | [VarDecl] bar | semmle.order | 0 | -| tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | tst.ts:104:28:104:44 | [TemplateLiteralTypeExpr] `hello ${string}` | semmle.label | 4 | -| tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | tst.ts:104:28:104:44 | [TemplateLiteralTypeExpr] `hello ${string}` | semmle.order | 4 | -| tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | tst.ts:104:46:107:3 | [BlockStmt] { / ... }`; } | semmle.label | 5 | -| tst.ts:104:3:107:3 | [FunctionDeclStmt] functio ... }`; } | tst.ts:104:46:107:3 | [BlockStmt] { / ... }`; } | semmle.order | 5 | -| tst.ts:104:16:104:16 | [SimpleParameter] s | tst.ts:104:19:104:24 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:104:16:104:16 | [SimpleParameter] s | tst.ts:104:19:104:24 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:104:28:104:44 | [TemplateLiteralTypeExpr] `hello ${string}` | tst.ts:104:29:104:34 | [LiteralTypeExpr] hello | semmle.label | 1 | -| tst.ts:104:28:104:44 | [TemplateLiteralTypeExpr] `hello ${string}` | tst.ts:104:29:104:34 | [LiteralTypeExpr] hello | semmle.order | 1 | -| tst.ts:104:28:104:44 | [TemplateLiteralTypeExpr] `hello ${string}` | tst.ts:104:37:104:42 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:104:28:104:44 | [TemplateLiteralTypeExpr] `hello ${string}` | tst.ts:104:37:104:42 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:104:46:107:3 | [BlockStmt] { / ... }`; } | tst.ts:106:5:106:24 | [ReturnStmt] return `hello ${s}`; | semmle.label | 1 | -| tst.ts:104:46:107:3 | [BlockStmt] { / ... }`; } | tst.ts:106:5:106:24 | [ReturnStmt] return `hello ${s}`; | semmle.order | 1 | -| tst.ts:106:5:106:24 | [ReturnStmt] return `hello ${s}`; | tst.ts:106:12:106:23 | [TemplateLiteral] `hello ${s}` | semmle.label | 1 | -| tst.ts:106:5:106:24 | [ReturnStmt] return `hello ${s}`; | tst.ts:106:12:106:23 | [TemplateLiteral] `hello ${s}` | semmle.order | 1 | -| tst.ts:106:12:106:23 | [TemplateLiteral] `hello ${s}` | tst.ts:106:13:106:18 | [TemplateElement] hello | semmle.label | 1 | -| tst.ts:106:12:106:23 | [TemplateLiteral] `hello ${s}` | tst.ts:106:13:106:18 | [TemplateElement] hello | semmle.order | 1 | -| tst.ts:106:12:106:23 | [TemplateLiteral] `hello ${s}` | tst.ts:106:21:106:21 | [VarRef] s | semmle.label | 2 | -| tst.ts:106:12:106:23 | [TemplateLiteral] `hello ${s}` | tst.ts:106:21:106:21 | [VarRef] s | semmle.order | 2 | -| tst.ts:109:3:109:50 | [DeclStmt] let s1 = ... | tst.ts:109:15:109:49 | [VariableDeclarator] s1: `${ ... umber}` | semmle.label | 1 | -| tst.ts:109:3:109:50 | [DeclStmt] let s1 = ... | tst.ts:109:15:109:49 | [VariableDeclarator] s1: `${ ... umber}` | semmle.order | 1 | -| tst.ts:109:15:109:49 | [VariableDeclarator] s1: `${ ... umber}` | tst.ts:109:15:109:16 | [VarDecl] s1 | semmle.label | 1 | -| tst.ts:109:15:109:49 | [VariableDeclarator] s1: `${ ... umber}` | tst.ts:109:15:109:16 | [VarDecl] s1 | semmle.order | 1 | -| tst.ts:109:15:109:49 | [VariableDeclarator] s1: `${ ... umber}` | tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | semmle.label | 2 | -| tst.ts:109:15:109:49 | [VariableDeclarator] s1: `${ ... umber}` | tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | semmle.order | 2 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:22:109:27 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:22:109:27 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:29:109:29 | [LiteralTypeExpr] - | semmle.label | 2 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:29:109:29 | [LiteralTypeExpr] - | semmle.order | 2 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:32:109:37 | [KeywordTypeExpr] number | semmle.label | 3 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:32:109:37 | [KeywordTypeExpr] number | semmle.order | 3 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:39:109:39 | [LiteralTypeExpr] - | semmle.label | 4 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:39:109:39 | [LiteralTypeExpr] - | semmle.order | 4 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:42:109:47 | [KeywordTypeExpr] number | semmle.label | 5 | -| tst.ts:109:19:109:49 | [TemplateLiteralTypeExpr] `${numb ... umber}` | tst.ts:109:42:109:47 | [KeywordTypeExpr] number | semmle.order | 5 | -| tst.ts:110:3:110:26 | [DeclStmt] let s2 = ... | tst.ts:110:15:110:25 | [VariableDeclarator] s2: `1-2-3` | semmle.label | 1 | -| tst.ts:110:3:110:26 | [DeclStmt] let s2 = ... | tst.ts:110:15:110:25 | [VariableDeclarator] s2: `1-2-3` | semmle.order | 1 | -| tst.ts:110:15:110:25 | [VariableDeclarator] s2: `1-2-3` | tst.ts:110:15:110:16 | [VarDecl] s2 | semmle.label | 1 | -| tst.ts:110:15:110:25 | [VariableDeclarator] s2: `1-2-3` | tst.ts:110:15:110:16 | [VarDecl] s2 | semmle.order | 1 | -| tst.ts:110:15:110:25 | [VariableDeclarator] s2: `1-2-3` | tst.ts:110:19:110:25 | [TemplateLiteralTypeExpr] `1-2-3` | semmle.label | 2 | -| tst.ts:110:15:110:25 | [VariableDeclarator] s2: `1-2-3` | tst.ts:110:19:110:25 | [TemplateLiteralTypeExpr] `1-2-3` | semmle.order | 2 | -| tst.ts:110:19:110:25 | [TemplateLiteralTypeExpr] `1-2-3` | tst.ts:110:19:110:25 | [LiteralTypeExpr] `1-2-3` | semmle.label | 1 | -| tst.ts:110:19:110:25 | [TemplateLiteralTypeExpr] `1-2-3` | tst.ts:110:19:110:25 | [LiteralTypeExpr] `1-2-3` | semmle.order | 1 | -| tst.ts:111:3:111:34 | [DeclStmt] let s3 = ... | tst.ts:111:15:111:33 | [VariableDeclarator] s3: `${number}-2-3` | semmle.label | 1 | -| tst.ts:111:3:111:34 | [DeclStmt] let s3 = ... | tst.ts:111:15:111:33 | [VariableDeclarator] s3: `${number}-2-3` | semmle.order | 1 | -| tst.ts:111:15:111:33 | [VariableDeclarator] s3: `${number}-2-3` | tst.ts:111:15:111:16 | [VarDecl] s3 | semmle.label | 1 | -| tst.ts:111:15:111:33 | [VariableDeclarator] s3: `${number}-2-3` | tst.ts:111:15:111:16 | [VarDecl] s3 | semmle.order | 1 | -| tst.ts:111:15:111:33 | [VariableDeclarator] s3: `${number}-2-3` | tst.ts:111:19:111:33 | [TemplateLiteralTypeExpr] `${number}-2-3` | semmle.label | 2 | -| tst.ts:111:15:111:33 | [VariableDeclarator] s3: `${number}-2-3` | tst.ts:111:19:111:33 | [TemplateLiteralTypeExpr] `${number}-2-3` | semmle.order | 2 | -| tst.ts:111:19:111:33 | [TemplateLiteralTypeExpr] `${number}-2-3` | tst.ts:111:22:111:27 | [KeywordTypeExpr] number | semmle.label | 1 | -| tst.ts:111:19:111:33 | [TemplateLiteralTypeExpr] `${number}-2-3` | tst.ts:111:22:111:27 | [KeywordTypeExpr] number | semmle.order | 1 | -| tst.ts:111:19:111:33 | [TemplateLiteralTypeExpr] `${number}-2-3` | tst.ts:111:29:111:32 | [LiteralTypeExpr] -2-3 | semmle.label | 2 | -| tst.ts:111:19:111:33 | [TemplateLiteralTypeExpr] `${number}-2-3` | tst.ts:111:29:111:32 | [LiteralTypeExpr] -2-3 | semmle.order | 2 | -| tst.ts:112:3:112:9 | [AssignExpr] s1 = s2 | tst.ts:112:3:112:4 | [VarRef] s1 | semmle.label | 1 | -| tst.ts:112:3:112:9 | [AssignExpr] s1 = s2 | tst.ts:112:3:112:4 | [VarRef] s1 | semmle.order | 1 | -| tst.ts:112:3:112:9 | [AssignExpr] s1 = s2 | tst.ts:112:8:112:9 | [VarRef] s2 | semmle.label | 2 | -| tst.ts:112:3:112:9 | [AssignExpr] s1 = s2 | tst.ts:112:8:112:9 | [VarRef] s2 | semmle.order | 2 | -| tst.ts:112:3:112:10 | [ExprStmt] s1 = s2; | tst.ts:112:3:112:9 | [AssignExpr] s1 = s2 | semmle.label | 1 | -| tst.ts:112:3:112:10 | [ExprStmt] s1 = s2; | tst.ts:112:3:112:9 | [AssignExpr] s1 = s2 | semmle.order | 1 | -| tst.ts:113:3:113:9 | [AssignExpr] s1 = s3 | tst.ts:113:3:113:4 | [VarRef] s1 | semmle.label | 1 | -| tst.ts:113:3:113:9 | [AssignExpr] s1 = s3 | tst.ts:113:3:113:4 | [VarRef] s1 | semmle.order | 1 | -| tst.ts:113:3:113:9 | [AssignExpr] s1 = s3 | tst.ts:113:8:113:9 | [VarRef] s3 | semmle.label | 2 | -| tst.ts:113:3:113:9 | [AssignExpr] s1 = s3 | tst.ts:113:8:113:9 | [VarRef] s3 | semmle.order | 2 | -| tst.ts:113:3:113:10 | [ExprStmt] s1 = s3; | tst.ts:113:3:113:9 | [AssignExpr] s1 = s3 | semmle.label | 1 | -| tst.ts:113:3:113:10 | [ExprStmt] s1 = s3; | tst.ts:113:3:113:9 | [AssignExpr] s1 = s3 | semmle.order | 1 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:116:9:116:11 | [VarDecl] Foo | semmle.label | 1 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:116:9:116:11 | [VarDecl] Foo | semmle.order | 1 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:116:13:116:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | 2 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:116:13:116:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.order | 2 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:117:5:119:5 | [ClassInitializedMember,MethodDefinition] #someMe ... ; } | semmle.label | 3 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:117:5:119:5 | [ClassInitializedMember,MethodDefinition] #someMe ... ; } | semmle.order | 3 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:121:5:123:5 | [ClassInitializedMember,GetterMethodDefinition] get #so ... ; } | semmle.label | 4 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:121:5:123:5 | [ClassInitializedMember,GetterMethodDefinition] get #so ... ; } | semmle.order | 4 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:125:5:128:5 | [ClassInitializedMember,MethodDefinition] publicM ... ; } | semmle.label | 5 | -| tst.ts:116:3:129:3 | [ClassDefinition,TypeDefinition] class F ... } } | tst.ts:125:5:128:5 | [ClassInitializedMember,MethodDefinition] publicM ... ; } | semmle.order | 5 | -| tst.ts:116:13:116:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:116:13:116:12 | [FunctionExpr] () {} | semmle.label | 2 | -| tst.ts:116:13:116:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:116:13:116:12 | [FunctionExpr] () {} | semmle.order | 2 | -| tst.ts:116:13:116:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:116:13:116:12 | [Label] constructor | semmle.label | 1 | -| tst.ts:116:13:116:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:116:13:116:12 | [Label] constructor | semmle.order | 1 | -| tst.ts:116:13:116:12 | [FunctionExpr] () {} | tst.ts:116:13:116:12 | [BlockStmt] {} | semmle.label | 5 | -| tst.ts:116:13:116:12 | [FunctionExpr] () {} | tst.ts:116:13:116:12 | [BlockStmt] {} | semmle.order | 5 | -| tst.ts:117:5:119:5 | [ClassInitializedMember,MethodDefinition] #someMe ... ; } | tst.ts:117:5:117:15 | [Label] #someMethod | semmle.label | 1 | -| tst.ts:117:5:119:5 | [ClassInitializedMember,MethodDefinition] #someMe ... ; } | tst.ts:117:5:117:15 | [Label] #someMethod | semmle.order | 1 | -| tst.ts:117:5:119:5 | [ClassInitializedMember,MethodDefinition] #someMe ... ; } | tst.ts:117:5:119:5 | [FunctionExpr] #someMe ... ; } | semmle.label | 2 | -| tst.ts:117:5:119:5 | [ClassInitializedMember,MethodDefinition] #someMe ... ; } | tst.ts:117:5:119:5 | [FunctionExpr] #someMe ... ; } | semmle.order | 2 | -| tst.ts:117:5:119:5 | [FunctionExpr] #someMe ... ; } | tst.ts:117:20:117:25 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:117:5:119:5 | [FunctionExpr] #someMe ... ; } | tst.ts:117:20:117:25 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:117:5:119:5 | [FunctionExpr] #someMe ... ; } | tst.ts:117:27:119:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:117:5:119:5 | [FunctionExpr] #someMe ... ; } | tst.ts:117:27:119:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:117:27:119:5 | [BlockStmt] { ... ; } | tst.ts:118:7:118:16 | [ReturnStmt] return 42; | semmle.label | 1 | -| tst.ts:117:27:119:5 | [BlockStmt] { ... ; } | tst.ts:118:7:118:16 | [ReturnStmt] return 42; | semmle.order | 1 | -| tst.ts:118:7:118:16 | [ReturnStmt] return 42; | tst.ts:118:14:118:15 | [Literal] 42 | semmle.label | 1 | -| tst.ts:118:7:118:16 | [ReturnStmt] return 42; | tst.ts:118:14:118:15 | [Literal] 42 | semmle.order | 1 | -| tst.ts:121:5:123:5 | [ClassInitializedMember,GetterMethodDefinition] get #so ... ; } | tst.ts:121:5:123:5 | [FunctionExpr] get #so ... ; } | semmle.label | 1 | -| tst.ts:121:5:123:5 | [ClassInitializedMember,GetterMethodDefinition] get #so ... ; } | tst.ts:121:5:123:5 | [FunctionExpr] get #so ... ; } | semmle.order | 1 | -| tst.ts:121:5:123:5 | [ClassInitializedMember,GetterMethodDefinition] get #so ... ; } | tst.ts:121:9:121:18 | [Label] #someValue | semmle.label | 2 | -| tst.ts:121:5:123:5 | [ClassInitializedMember,GetterMethodDefinition] get #so ... ; } | tst.ts:121:9:121:18 | [Label] #someValue | semmle.order | 2 | -| tst.ts:121:5:123:5 | [FunctionExpr] get #so ... ; } | tst.ts:121:23:121:28 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:121:5:123:5 | [FunctionExpr] get #so ... ; } | tst.ts:121:23:121:28 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:121:5:123:5 | [FunctionExpr] get #so ... ; } | tst.ts:121:30:123:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:121:5:123:5 | [FunctionExpr] get #so ... ; } | tst.ts:121:30:123:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:121:30:123:5 | [BlockStmt] { ... ; } | tst.ts:122:7:122:17 | [ReturnStmt] return 100; | semmle.label | 1 | -| tst.ts:121:30:123:5 | [BlockStmt] { ... ; } | tst.ts:122:7:122:17 | [ReturnStmt] return 100; | semmle.order | 1 | -| tst.ts:122:7:122:17 | [ReturnStmt] return 100; | tst.ts:122:14:122:16 | [Literal] 100 | semmle.label | 1 | -| tst.ts:122:7:122:17 | [ReturnStmt] return 100; | tst.ts:122:14:122:16 | [Literal] 100 | semmle.order | 1 | -| tst.ts:125:5:128:5 | [ClassInitializedMember,MethodDefinition] publicM ... ; } | tst.ts:125:5:125:16 | [Label] publicMethod | semmle.label | 1 | -| tst.ts:125:5:128:5 | [ClassInitializedMember,MethodDefinition] publicM ... ; } | tst.ts:125:5:125:16 | [Label] publicMethod | semmle.order | 1 | -| tst.ts:125:5:128:5 | [ClassInitializedMember,MethodDefinition] publicM ... ; } | tst.ts:125:5:128:5 | [FunctionExpr] publicM ... ; } | semmle.label | 2 | -| tst.ts:125:5:128:5 | [ClassInitializedMember,MethodDefinition] publicM ... ; } | tst.ts:125:5:128:5 | [FunctionExpr] publicM ... ; } | semmle.order | 2 | -| tst.ts:125:5:128:5 | [FunctionExpr] publicM ... ; } | tst.ts:125:20:128:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:125:5:128:5 | [FunctionExpr] publicM ... ; } | tst.ts:125:20:128:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:125:20:128:5 | [BlockStmt] { ... ; } | tst.ts:126:7:126:25 | [ExprStmt] this.#someMethod(); | semmle.label | 1 | -| tst.ts:125:20:128:5 | [BlockStmt] { ... ; } | tst.ts:126:7:126:25 | [ExprStmt] this.#someMethod(); | semmle.order | 1 | -| tst.ts:125:20:128:5 | [BlockStmt] { ... ; } | tst.ts:127:7:127:29 | [ReturnStmt] return ... eValue; | semmle.label | 2 | -| tst.ts:125:20:128:5 | [BlockStmt] { ... ; } | tst.ts:127:7:127:29 | [ReturnStmt] return ... eValue; | semmle.order | 2 | -| tst.ts:126:7:126:22 | [DotExpr] this.#someMethod | tst.ts:126:7:126:10 | [ThisExpr] this | semmle.label | 1 | -| tst.ts:126:7:126:22 | [DotExpr] this.#someMethod | tst.ts:126:7:126:10 | [ThisExpr] this | semmle.order | 1 | -| tst.ts:126:7:126:22 | [DotExpr] this.#someMethod | tst.ts:126:12:126:22 | [Label] #someMethod | semmle.label | 2 | -| tst.ts:126:7:126:22 | [DotExpr] this.#someMethod | tst.ts:126:12:126:22 | [Label] #someMethod | semmle.order | 2 | -| tst.ts:126:7:126:24 | [MethodCallExpr] this.#someMethod() | tst.ts:126:7:126:22 | [DotExpr] this.#someMethod | semmle.label | 0 | -| tst.ts:126:7:126:24 | [MethodCallExpr] this.#someMethod() | tst.ts:126:7:126:22 | [DotExpr] this.#someMethod | semmle.order | 0 | -| tst.ts:126:7:126:25 | [ExprStmt] this.#someMethod(); | tst.ts:126:7:126:24 | [MethodCallExpr] this.#someMethod() | semmle.label | 1 | -| tst.ts:126:7:126:25 | [ExprStmt] this.#someMethod(); | tst.ts:126:7:126:24 | [MethodCallExpr] this.#someMethod() | semmle.order | 1 | -| tst.ts:127:7:127:29 | [ReturnStmt] return ... eValue; | tst.ts:127:14:127:28 | [DotExpr] this.#someValue | semmle.label | 1 | -| tst.ts:127:7:127:29 | [ReturnStmt] return ... eValue; | tst.ts:127:14:127:28 | [DotExpr] this.#someValue | semmle.order | 1 | -| tst.ts:127:14:127:28 | [DotExpr] this.#someValue | tst.ts:127:14:127:17 | [ThisExpr] this | semmle.label | 1 | -| tst.ts:127:14:127:28 | [DotExpr] this.#someValue | tst.ts:127:14:127:17 | [ThisExpr] this | semmle.order | 1 | -| tst.ts:127:14:127:28 | [DotExpr] this.#someValue | tst.ts:127:19:127:28 | [Label] #someValue | semmle.label | 2 | -| tst.ts:127:14:127:28 | [DotExpr] this.#someValue | tst.ts:127:19:127:28 | [Label] #someValue | semmle.order | 2 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:132:8:132:11 | [VarDecl] TS44 | semmle.label | 1 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:132:8:132:11 | [VarDecl] TS44 | semmle.order | 1 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:133:3:138:3 | [FunctionDeclStmt] functio ... } } | semmle.label | 2 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:133:3:138:3 | [FunctionDeclStmt] functio ... } } | semmle.order | 2 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:140:3:142:47 | [TypeAliasDeclaration,TypeDefinition] type Sh ... mber }; | semmle.label | 3 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:140:3:142:47 | [TypeAliasDeclaration,TypeDefinition] type Sh ... mber }; | semmle.order | 3 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | semmle.label | 4 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | semmle.order | 4 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:151:3:162:3 | [FunctionDeclStmt] functio ... 2]; } | semmle.label | 5 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:151:3:162:3 | [FunctionDeclStmt] functio ... 2]; } | semmle.order | 5 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:164:3:177:3 | [FunctionDeclStmt] functio ... "]; } | semmle.label | 6 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:164:3:177:3 | [FunctionDeclStmt] functio ... "]; } | semmle.order | 6 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | semmle.label | 7 | -| tst.ts:132:1:193:1 | [NamespaceDeclaration] module ... } } | tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | semmle.order | 7 | -| tst.ts:133:3:138:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:133:3:138:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:133:3:138:3 | [FunctionDeclStmt] functio ... } } | tst.ts:133:12:133:14 | [VarDecl] foo | semmle.label | 0 | -| tst.ts:133:3:138:3 | [FunctionDeclStmt] functio ... } } | tst.ts:133:12:133:14 | [VarDecl] foo | semmle.order | 0 | -| tst.ts:133:3:138:3 | [FunctionDeclStmt] functio ... } } | tst.ts:133:30:138:3 | [BlockStmt] { c ... } } | semmle.label | 5 | -| tst.ts:133:3:138:3 | [FunctionDeclStmt] functio ... } } | tst.ts:133:30:138:3 | [BlockStmt] { c ... } } | semmle.order | 5 | -| tst.ts:133:16:133:18 | [SimpleParameter] arg | tst.ts:133:21:133:27 | [KeywordTypeExpr] unknown | semmle.label | -2 | -| tst.ts:133:16:133:18 | [SimpleParameter] arg | tst.ts:133:21:133:27 | [KeywordTypeExpr] unknown | semmle.order | -2 | -| tst.ts:133:30:138:3 | [BlockStmt] { c ... } } | tst.ts:134:5:134:48 | [DeclStmt] const argIsString = ... | semmle.label | 1 | -| tst.ts:133:30:138:3 | [BlockStmt] { c ... } } | tst.ts:134:5:134:48 | [DeclStmt] const argIsString = ... | semmle.order | 1 | -| tst.ts:133:30:138:3 | [BlockStmt] { c ... } } | tst.ts:135:5:137:5 | [IfStmt] if (arg ... ; } | semmle.label | 2 | -| tst.ts:133:30:138:3 | [BlockStmt] { c ... } } | tst.ts:135:5:137:5 | [IfStmt] if (arg ... ; } | semmle.order | 2 | -| tst.ts:134:5:134:48 | [DeclStmt] const argIsString = ... | tst.ts:134:11:134:47 | [VariableDeclarator] argIsSt ... string" | semmle.label | 1 | -| tst.ts:134:5:134:48 | [DeclStmt] const argIsString = ... | tst.ts:134:11:134:47 | [VariableDeclarator] argIsSt ... string" | semmle.order | 1 | -| tst.ts:134:11:134:47 | [VariableDeclarator] argIsSt ... string" | tst.ts:134:11:134:21 | [VarDecl] argIsString | semmle.label | 1 | -| tst.ts:134:11:134:47 | [VariableDeclarator] argIsSt ... string" | tst.ts:134:11:134:21 | [VarDecl] argIsString | semmle.order | 1 | -| tst.ts:134:11:134:47 | [VariableDeclarator] argIsSt ... string" | tst.ts:134:25:134:47 | [BinaryExpr] typeof ... string" | semmle.label | 2 | -| tst.ts:134:11:134:47 | [VariableDeclarator] argIsSt ... string" | tst.ts:134:25:134:47 | [BinaryExpr] typeof ... string" | semmle.order | 2 | -| tst.ts:134:25:134:34 | [UnaryExpr] typeof arg | tst.ts:134:32:134:34 | [VarRef] arg | semmle.label | 1 | -| tst.ts:134:25:134:34 | [UnaryExpr] typeof arg | tst.ts:134:32:134:34 | [VarRef] arg | semmle.order | 1 | -| tst.ts:134:25:134:47 | [BinaryExpr] typeof ... string" | tst.ts:134:25:134:34 | [UnaryExpr] typeof arg | semmle.label | 1 | -| tst.ts:134:25:134:47 | [BinaryExpr] typeof ... string" | tst.ts:134:25:134:34 | [UnaryExpr] typeof arg | semmle.order | 1 | -| tst.ts:134:25:134:47 | [BinaryExpr] typeof ... string" | tst.ts:134:40:134:47 | [Literal] "string" | semmle.label | 2 | -| tst.ts:134:25:134:47 | [BinaryExpr] typeof ... string" | tst.ts:134:40:134:47 | [Literal] "string" | semmle.order | 2 | -| tst.ts:135:5:137:5 | [IfStmt] if (arg ... ; } | tst.ts:135:9:135:19 | [VarRef] argIsString | semmle.label | 1 | -| tst.ts:135:5:137:5 | [IfStmt] if (arg ... ; } | tst.ts:135:9:135:19 | [VarRef] argIsString | semmle.order | 1 | -| tst.ts:135:5:137:5 | [IfStmt] if (arg ... ; } | tst.ts:135:22:137:5 | [BlockStmt] { ... ; } | semmle.label | 2 | -| tst.ts:135:5:137:5 | [IfStmt] if (arg ... ; } | tst.ts:135:22:137:5 | [BlockStmt] { ... ; } | semmle.order | 2 | -| tst.ts:135:22:137:5 | [BlockStmt] { ... ; } | tst.ts:136:9:136:40 | [DeclStmt] const upper = ... | semmle.label | 1 | -| tst.ts:135:22:137:5 | [BlockStmt] { ... ; } | tst.ts:136:9:136:40 | [DeclStmt] const upper = ... | semmle.order | 1 | -| tst.ts:136:9:136:40 | [DeclStmt] const upper = ... | tst.ts:136:15:136:39 | [VariableDeclarator] upper = ... rCase() | semmle.label | 1 | -| tst.ts:136:9:136:40 | [DeclStmt] const upper = ... | tst.ts:136:15:136:39 | [VariableDeclarator] upper = ... rCase() | semmle.order | 1 | -| tst.ts:136:15:136:39 | [VariableDeclarator] upper = ... rCase() | tst.ts:136:15:136:19 | [VarDecl] upper | semmle.label | 1 | -| tst.ts:136:15:136:39 | [VariableDeclarator] upper = ... rCase() | tst.ts:136:15:136:19 | [VarDecl] upper | semmle.order | 1 | -| tst.ts:136:15:136:39 | [VariableDeclarator] upper = ... rCase() | tst.ts:136:23:136:39 | [MethodCallExpr] arg.toUpperCase() | semmle.label | 2 | -| tst.ts:136:15:136:39 | [VariableDeclarator] upper = ... rCase() | tst.ts:136:23:136:39 | [MethodCallExpr] arg.toUpperCase() | semmle.order | 2 | -| tst.ts:136:23:136:37 | [DotExpr] arg.toUpperCase | tst.ts:136:23:136:25 | [VarRef] arg | semmle.label | 1 | -| tst.ts:136:23:136:37 | [DotExpr] arg.toUpperCase | tst.ts:136:23:136:25 | [VarRef] arg | semmle.order | 1 | -| tst.ts:136:23:136:37 | [DotExpr] arg.toUpperCase | tst.ts:136:27:136:37 | [Label] toUpperCase | semmle.label | 2 | -| tst.ts:136:23:136:37 | [DotExpr] arg.toUpperCase | tst.ts:136:27:136:37 | [Label] toUpperCase | semmle.order | 2 | -| tst.ts:136:23:136:39 | [MethodCallExpr] arg.toUpperCase() | tst.ts:136:23:136:37 | [DotExpr] arg.toUpperCase | semmle.label | 0 | -| tst.ts:136:23:136:39 | [MethodCallExpr] arg.toUpperCase() | tst.ts:136:23:136:37 | [DotExpr] arg.toUpperCase | semmle.order | 0 | -| tst.ts:140:3:142:47 | [TypeAliasDeclaration,TypeDefinition] type Sh ... mber }; | tst.ts:140:8:140:12 | [Identifier] Shape | semmle.label | 1 | -| tst.ts:140:3:142:47 | [TypeAliasDeclaration,TypeDefinition] type Sh ... mber }; | tst.ts:140:8:140:12 | [Identifier] Shape | semmle.order | 1 | -| tst.ts:140:3:142:47 | [TypeAliasDeclaration,TypeDefinition] type Sh ... mber }; | tst.ts:141:7:142:46 | [UnionTypeExpr] \| { kin ... umber } | semmle.label | 2 | -| tst.ts:140:3:142:47 | [TypeAliasDeclaration,TypeDefinition] type Sh ... mber }; | tst.ts:141:7:142:46 | [UnionTypeExpr] \| { kin ... umber } | semmle.order | 2 | -| tst.ts:141:7:142:46 | [UnionTypeExpr] \| { kin ... umber } | tst.ts:141:9:141:42 | [InterfaceTypeExpr] { kind: ... umber } | semmle.label | 1 | -| tst.ts:141:7:142:46 | [UnionTypeExpr] \| { kin ... umber } | tst.ts:141:9:141:42 | [InterfaceTypeExpr] { kind: ... umber } | semmle.order | 1 | -| tst.ts:141:7:142:46 | [UnionTypeExpr] \| { kin ... umber } | tst.ts:142:9:142:46 | [InterfaceTypeExpr] { kind: ... umber } | semmle.label | 2 | -| tst.ts:141:7:142:46 | [UnionTypeExpr] \| { kin ... umber } | tst.ts:142:9:142:46 | [InterfaceTypeExpr] { kind: ... umber } | semmle.order | 2 | -| tst.ts:141:9:141:42 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:141:11:141:25 | [FieldDeclaration] kind: "circle", | semmle.label | 1 | -| tst.ts:141:9:141:42 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:141:11:141:25 | [FieldDeclaration] kind: "circle", | semmle.order | 1 | -| tst.ts:141:9:141:42 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:141:27:141:40 | [FieldDeclaration] radius: number | semmle.label | 2 | -| tst.ts:141:9:141:42 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:141:27:141:40 | [FieldDeclaration] radius: number | semmle.order | 2 | -| tst.ts:141:11:141:25 | [FieldDeclaration] kind: "circle", | tst.ts:141:11:141:14 | [Label] kind | semmle.label | 1 | -| tst.ts:141:11:141:25 | [FieldDeclaration] kind: "circle", | tst.ts:141:11:141:14 | [Label] kind | semmle.order | 1 | -| tst.ts:141:11:141:25 | [FieldDeclaration] kind: "circle", | tst.ts:141:17:141:24 | [LiteralTypeExpr] "circle" | semmle.label | 2 | -| tst.ts:141:11:141:25 | [FieldDeclaration] kind: "circle", | tst.ts:141:17:141:24 | [LiteralTypeExpr] "circle" | semmle.order | 2 | -| tst.ts:141:27:141:40 | [FieldDeclaration] radius: number | tst.ts:141:27:141:32 | [Label] radius | semmle.label | 1 | -| tst.ts:141:27:141:40 | [FieldDeclaration] radius: number | tst.ts:141:27:141:32 | [Label] radius | semmle.order | 1 | -| tst.ts:141:27:141:40 | [FieldDeclaration] radius: number | tst.ts:141:35:141:40 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:141:27:141:40 | [FieldDeclaration] radius: number | tst.ts:141:35:141:40 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:142:9:142:46 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:142:11:142:25 | [FieldDeclaration] kind: "square", | semmle.label | 1 | -| tst.ts:142:9:142:46 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:142:11:142:25 | [FieldDeclaration] kind: "square", | semmle.order | 1 | -| tst.ts:142:9:142:46 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:142:27:142:44 | [FieldDeclaration] sideLength: number | semmle.label | 2 | -| tst.ts:142:9:142:46 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:142:27:142:44 | [FieldDeclaration] sideLength: number | semmle.order | 2 | -| tst.ts:142:11:142:25 | [FieldDeclaration] kind: "square", | tst.ts:142:11:142:14 | [Label] kind | semmle.label | 1 | -| tst.ts:142:11:142:25 | [FieldDeclaration] kind: "square", | tst.ts:142:11:142:14 | [Label] kind | semmle.order | 1 | -| tst.ts:142:11:142:25 | [FieldDeclaration] kind: "square", | tst.ts:142:17:142:24 | [LiteralTypeExpr] "square" | semmle.label | 2 | -| tst.ts:142:11:142:25 | [FieldDeclaration] kind: "square", | tst.ts:142:17:142:24 | [LiteralTypeExpr] "square" | semmle.order | 2 | -| tst.ts:142:27:142:44 | [FieldDeclaration] sideLength: number | tst.ts:142:27:142:36 | [Label] sideLength | semmle.label | 1 | -| tst.ts:142:27:142:44 | [FieldDeclaration] sideLength: number | tst.ts:142:27:142:36 | [Label] sideLength | semmle.order | 1 | -| tst.ts:142:27:142:44 | [FieldDeclaration] sideLength: number | tst.ts:142:39:142:44 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:142:27:142:44 | [FieldDeclaration] sideLength: number | tst.ts:142:39:142:44 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | tst.ts:144:12:144:15 | [VarDecl] side | semmle.label | 0 | -| tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | tst.ts:144:12:144:15 | [VarDecl] side | semmle.order | 0 | -| tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | tst.ts:144:32:144:37 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | tst.ts:144:32:144:37 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | tst.ts:144:39:149:3 | [BlockStmt] { ... ; } } | semmle.label | 5 | -| tst.ts:144:3:149:3 | [FunctionDeclStmt] functio ... ; } } | tst.ts:144:39:149:3 | [BlockStmt] { ... ; } } | semmle.order | 5 | -| tst.ts:144:17:144:21 | [SimpleParameter] shape | tst.ts:144:24:144:28 | [LocalTypeAccess] Shape | semmle.label | -2 | -| tst.ts:144:17:144:21 | [SimpleParameter] shape | tst.ts:144:24:144:28 | [LocalTypeAccess] Shape | semmle.order | -2 | -| tst.ts:144:39:149:3 | [BlockStmt] { ... ; } } | tst.ts:145:7:145:29 | [DeclStmt] const { ... shape; | semmle.label | 1 | -| tst.ts:144:39:149:3 | [BlockStmt] { ... ; } } | tst.ts:145:7:145:29 | [DeclStmt] const { ... shape; | semmle.order | 1 | -| tst.ts:144:39:149:3 | [BlockStmt] { ... ; } } | tst.ts:147:7:148:39 | [IfStmt] if (kin ... ngth; } | semmle.label | 2 | -| tst.ts:144:39:149:3 | [BlockStmt] { ... ; } } | tst.ts:147:7:148:39 | [IfStmt] if (kin ... ngth; } | semmle.order | 2 | -| tst.ts:145:7:145:29 | [DeclStmt] const { ... shape; | tst.ts:145:13:145:28 | [VariableDeclarator] { kind } = shape | semmle.label | 1 | -| tst.ts:145:7:145:29 | [DeclStmt] const { ... shape; | tst.ts:145:13:145:28 | [VariableDeclarator] { kind } = shape | semmle.order | 1 | -| tst.ts:145:13:145:20 | [ObjectPattern] { kind } | tst.ts:145:15:145:18 | [PropertyPattern] kind | semmle.label | 1 | -| tst.ts:145:13:145:20 | [ObjectPattern] { kind } | tst.ts:145:15:145:18 | [PropertyPattern] kind | semmle.order | 1 | -| tst.ts:145:13:145:28 | [VariableDeclarator] { kind } = shape | tst.ts:145:13:145:20 | [ObjectPattern] { kind } | semmle.label | 1 | -| tst.ts:145:13:145:28 | [VariableDeclarator] { kind } = shape | tst.ts:145:13:145:20 | [ObjectPattern] { kind } | semmle.order | 1 | -| tst.ts:145:13:145:28 | [VariableDeclarator] { kind } = shape | tst.ts:145:24:145:28 | [VarRef] shape | semmle.label | 2 | -| tst.ts:145:13:145:28 | [VariableDeclarator] { kind } = shape | tst.ts:145:24:145:28 | [VarRef] shape | semmle.order | 2 | -| tst.ts:145:15:145:18 | [PropertyPattern] kind | tst.ts:145:15:145:18 | [Label] kind | semmle.label | 1 | -| tst.ts:145:15:145:18 | [PropertyPattern] kind | tst.ts:145:15:145:18 | [Label] kind | semmle.order | 1 | -| tst.ts:145:15:145:18 | [PropertyPattern] kind | tst.ts:145:15:145:18 | [VarDecl] kind | semmle.label | 2 | -| tst.ts:145:15:145:18 | [PropertyPattern] kind | tst.ts:145:15:145:18 | [VarDecl] kind | semmle.order | 2 | -| tst.ts:147:7:148:39 | [IfStmt] if (kin ... ngth; } | tst.ts:147:11:147:27 | [BinaryExpr] kind === "circle" | semmle.label | 1 | -| tst.ts:147:7:148:39 | [IfStmt] if (kin ... ngth; } | tst.ts:147:11:147:27 | [BinaryExpr] kind === "circle" | semmle.order | 1 | -| tst.ts:147:7:148:39 | [IfStmt] if (kin ... ngth; } | tst.ts:147:30:147:52 | [BlockStmt] { retur ... adius;} | semmle.label | 2 | -| tst.ts:147:7:148:39 | [IfStmt] if (kin ... ngth; } | tst.ts:147:30:147:52 | [BlockStmt] { retur ... adius;} | semmle.order | 2 | -| tst.ts:147:7:148:39 | [IfStmt] if (kin ... ngth; } | tst.ts:148:12:148:39 | [BlockStmt] { retur ... ngth; } | semmle.label | 3 | -| tst.ts:147:7:148:39 | [IfStmt] if (kin ... ngth; } | tst.ts:148:12:148:39 | [BlockStmt] { retur ... ngth; } | semmle.order | 3 | -| tst.ts:147:11:147:27 | [BinaryExpr] kind === "circle" | tst.ts:147:11:147:14 | [VarRef] kind | semmle.label | 1 | -| tst.ts:147:11:147:27 | [BinaryExpr] kind === "circle" | tst.ts:147:11:147:14 | [VarRef] kind | semmle.order | 1 | -| tst.ts:147:11:147:27 | [BinaryExpr] kind === "circle" | tst.ts:147:20:147:27 | [Literal] "circle" | semmle.label | 2 | -| tst.ts:147:11:147:27 | [BinaryExpr] kind === "circle" | tst.ts:147:20:147:27 | [Literal] "circle" | semmle.order | 2 | -| tst.ts:147:30:147:52 | [BlockStmt] { retur ... adius;} | tst.ts:147:32:147:51 | [ReturnStmt] return shape.radius; | semmle.label | 1 | -| tst.ts:147:30:147:52 | [BlockStmt] { retur ... adius;} | tst.ts:147:32:147:51 | [ReturnStmt] return shape.radius; | semmle.order | 1 | -| tst.ts:147:32:147:51 | [ReturnStmt] return shape.radius; | tst.ts:147:39:147:50 | [DotExpr] shape.radius | semmle.label | 1 | -| tst.ts:147:32:147:51 | [ReturnStmt] return shape.radius; | tst.ts:147:39:147:50 | [DotExpr] shape.radius | semmle.order | 1 | -| tst.ts:147:39:147:50 | [DotExpr] shape.radius | tst.ts:147:39:147:43 | [VarRef] shape | semmle.label | 1 | -| tst.ts:147:39:147:50 | [DotExpr] shape.radius | tst.ts:147:39:147:43 | [VarRef] shape | semmle.order | 1 | -| tst.ts:147:39:147:50 | [DotExpr] shape.radius | tst.ts:147:45:147:50 | [Label] radius | semmle.label | 2 | -| tst.ts:147:39:147:50 | [DotExpr] shape.radius | tst.ts:147:45:147:50 | [Label] radius | semmle.order | 2 | -| tst.ts:148:12:148:39 | [BlockStmt] { retur ... ngth; } | tst.ts:148:14:148:37 | [ReturnStmt] return ... Length; | semmle.label | 1 | -| tst.ts:148:12:148:39 | [BlockStmt] { retur ... ngth; } | tst.ts:148:14:148:37 | [ReturnStmt] return ... Length; | semmle.order | 1 | -| tst.ts:148:14:148:37 | [ReturnStmt] return ... Length; | tst.ts:148:21:148:36 | [DotExpr] shape.sideLength | semmle.label | 1 | -| tst.ts:148:14:148:37 | [ReturnStmt] return ... Length; | tst.ts:148:21:148:36 | [DotExpr] shape.sideLength | semmle.order | 1 | -| tst.ts:148:21:148:36 | [DotExpr] shape.sideLength | tst.ts:148:21:148:25 | [VarRef] shape | semmle.label | 1 | -| tst.ts:148:21:148:36 | [DotExpr] shape.sideLength | tst.ts:148:21:148:25 | [VarRef] shape | semmle.order | 1 | -| tst.ts:148:21:148:36 | [DotExpr] shape.sideLength | tst.ts:148:27:148:36 | [Label] sideLength | semmle.label | 2 | -| tst.ts:148:21:148:36 | [DotExpr] shape.sideLength | tst.ts:148:27:148:36 | [Label] sideLength | semmle.order | 2 | -| tst.ts:151:3:162:3 | [FunctionDeclStmt] functio ... 2]; } | tst.ts:151:12:151:22 | [VarDecl] symbolIndex | semmle.label | 0 | -| tst.ts:151:3:162:3 | [FunctionDeclStmt] functio ... 2]; } | tst.ts:151:12:151:22 | [VarDecl] symbolIndex | semmle.order | 0 | -| tst.ts:151:3:162:3 | [FunctionDeclStmt] functio ... 2]; } | tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | semmle.label | 5 | -| tst.ts:151:3:162:3 | [FunctionDeclStmt] functio ... 2]; } | tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | semmle.order | 5 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | semmle.label | 1 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | semmle.order | 1 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:158:5:158:28 | [DeclStmt] let colors = ... | semmle.label | 2 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:158:5:158:28 | [DeclStmt] let colors = ... | semmle.order | 2 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:159:5:159:38 | [DeclStmt] const red = ... | semmle.label | 3 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:159:5:159:38 | [DeclStmt] const red = ... | semmle.order | 3 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:160:5:160:34 | [DeclStmt] const green = ... | semmle.label | 4 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:160:5:160:34 | [DeclStmt] const green = ... | semmle.order | 4 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:161:5:161:27 | [DeclStmt] const blue = ... | semmle.label | 5 | -| tst.ts:151:26:162:3 | [BlockStmt] { i ... 2]; } | tst.ts:161:5:161:27 | [DeclStmt] const blue = ... | semmle.order | 5 | -| tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:152:15:152:20 | [Identifier] Colors | semmle.label | 1 | -| tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:152:15:152:20 | [Identifier] Colors | semmle.order | 1 | -| tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:153:7:153:28 | [IndexSignature] [sym: s ... number; | semmle.label | 2 | -| tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:153:7:153:28 | [IndexSignature] [sym: s ... number; | semmle.order | 2 | -| tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:154:7:154:28 | [IndexSignature] [key: s ... string; | semmle.label | 3 | -| tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:154:7:154:28 | [IndexSignature] [key: s ... string; | semmle.order | 3 | -| tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:155:7:155:29 | [IndexSignature] [num: n ... oolean; | semmle.label | 4 | -| tst.ts:152:5:156:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:155:7:155:29 | [IndexSignature] [num: n ... oolean; | semmle.order | 4 | -| tst.ts:153:7:153:28 | [FunctionExpr] [sym: s ... number; | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:153:7:153:28 | [FunctionExpr] [sym: s ... number; | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:153:7:153:28 | [FunctionExpr] [sym: s ... number; | tst.ts:153:22:153:27 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:153:7:153:28 | [FunctionExpr] [sym: s ... number; | tst.ts:153:22:153:27 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:153:7:153:28 | [IndexSignature] [sym: s ... number; | tst.ts:153:7:153:28 | [FunctionExpr] [sym: s ... number; | semmle.label | 1 | -| tst.ts:153:7:153:28 | [IndexSignature] [sym: s ... number; | tst.ts:153:7:153:28 | [FunctionExpr] [sym: s ... number; | semmle.order | 1 | -| tst.ts:153:8:153:10 | [SimpleParameter] sym | tst.ts:153:13:153:18 | [KeywordTypeExpr] symbol | semmle.label | -2 | -| tst.ts:153:8:153:10 | [SimpleParameter] sym | tst.ts:153:13:153:18 | [KeywordTypeExpr] symbol | semmle.order | -2 | -| tst.ts:154:7:154:28 | [FunctionExpr] [key: s ... string; | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:154:7:154:28 | [FunctionExpr] [key: s ... string; | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:154:7:154:28 | [FunctionExpr] [key: s ... string; | tst.ts:154:22:154:27 | [KeywordTypeExpr] string | semmle.label | 4 | -| tst.ts:154:7:154:28 | [FunctionExpr] [key: s ... string; | tst.ts:154:22:154:27 | [KeywordTypeExpr] string | semmle.order | 4 | -| tst.ts:154:7:154:28 | [IndexSignature] [key: s ... string; | tst.ts:154:7:154:28 | [FunctionExpr] [key: s ... string; | semmle.label | 1 | -| tst.ts:154:7:154:28 | [IndexSignature] [key: s ... string; | tst.ts:154:7:154:28 | [FunctionExpr] [key: s ... string; | semmle.order | 1 | -| tst.ts:154:8:154:10 | [SimpleParameter] key | tst.ts:154:13:154:18 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:154:8:154:10 | [SimpleParameter] key | tst.ts:154:13:154:18 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:155:7:155:29 | [FunctionExpr] [num: n ... oolean; | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:155:7:155:29 | [FunctionExpr] [num: n ... oolean; | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:155:7:155:29 | [FunctionExpr] [num: n ... oolean; | tst.ts:155:22:155:28 | [KeywordTypeExpr] boolean | semmle.label | 4 | -| tst.ts:155:7:155:29 | [FunctionExpr] [num: n ... oolean; | tst.ts:155:22:155:28 | [KeywordTypeExpr] boolean | semmle.order | 4 | -| tst.ts:155:7:155:29 | [IndexSignature] [num: n ... oolean; | tst.ts:155:7:155:29 | [FunctionExpr] [num: n ... oolean; | semmle.label | 1 | -| tst.ts:155:7:155:29 | [IndexSignature] [num: n ... oolean; | tst.ts:155:7:155:29 | [FunctionExpr] [num: n ... oolean; | semmle.order | 1 | -| tst.ts:155:8:155:10 | [SimpleParameter] num | tst.ts:155:13:155:18 | [KeywordTypeExpr] number | semmle.label | -2 | -| tst.ts:155:8:155:10 | [SimpleParameter] num | tst.ts:155:13:155:18 | [KeywordTypeExpr] number | semmle.order | -2 | -| tst.ts:158:5:158:28 | [DeclStmt] let colors = ... | tst.ts:158:9:158:27 | [VariableDeclarator] colors: Colors = {} | semmle.label | 1 | -| tst.ts:158:5:158:28 | [DeclStmt] let colors = ... | tst.ts:158:9:158:27 | [VariableDeclarator] colors: Colors = {} | semmle.order | 1 | -| tst.ts:158:9:158:27 | [VariableDeclarator] colors: Colors = {} | tst.ts:158:9:158:14 | [VarDecl] colors | semmle.label | 1 | -| tst.ts:158:9:158:27 | [VariableDeclarator] colors: Colors = {} | tst.ts:158:9:158:14 | [VarDecl] colors | semmle.order | 1 | -| tst.ts:158:9:158:27 | [VariableDeclarator] colors: Colors = {} | tst.ts:158:17:158:22 | [LocalTypeAccess] Colors | semmle.label | 2 | -| tst.ts:158:9:158:27 | [VariableDeclarator] colors: Colors = {} | tst.ts:158:17:158:22 | [LocalTypeAccess] Colors | semmle.order | 2 | -| tst.ts:158:9:158:27 | [VariableDeclarator] colors: Colors = {} | tst.ts:158:26:158:27 | [ObjectExpr] {} | semmle.label | 3 | -| tst.ts:158:9:158:27 | [VariableDeclarator] colors: Colors = {} | tst.ts:158:26:158:27 | [ObjectExpr] {} | semmle.order | 3 | -| tst.ts:159:5:159:38 | [DeclStmt] const red = ... | tst.ts:159:11:159:37 | [VariableDeclarator] red = c ... "red")] | semmle.label | 1 | -| tst.ts:159:5:159:38 | [DeclStmt] const red = ... | tst.ts:159:11:159:37 | [VariableDeclarator] red = c ... "red")] | semmle.order | 1 | -| tst.ts:159:11:159:37 | [VariableDeclarator] red = c ... "red")] | tst.ts:159:11:159:13 | [VarDecl] red | semmle.label | 1 | -| tst.ts:159:11:159:37 | [VariableDeclarator] red = c ... "red")] | tst.ts:159:11:159:13 | [VarDecl] red | semmle.order | 1 | -| tst.ts:159:11:159:37 | [VariableDeclarator] red = c ... "red")] | tst.ts:159:17:159:37 | [IndexExpr] colors[ ... "red")] | semmle.label | 2 | -| tst.ts:159:11:159:37 | [VariableDeclarator] red = c ... "red")] | tst.ts:159:17:159:37 | [IndexExpr] colors[ ... "red")] | semmle.order | 2 | -| tst.ts:159:17:159:37 | [IndexExpr] colors[ ... "red")] | tst.ts:159:17:159:22 | [VarRef] colors | semmle.label | 1 | -| tst.ts:159:17:159:37 | [IndexExpr] colors[ ... "red")] | tst.ts:159:17:159:22 | [VarRef] colors | semmle.order | 1 | -| tst.ts:159:17:159:37 | [IndexExpr] colors[ ... "red")] | tst.ts:159:24:159:36 | [CallExpr] Symbol("red") | semmle.label | 2 | -| tst.ts:159:17:159:37 | [IndexExpr] colors[ ... "red")] | tst.ts:159:24:159:36 | [CallExpr] Symbol("red") | semmle.order | 2 | -| tst.ts:159:24:159:36 | [CallExpr] Symbol("red") | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:159:24:159:36 | [CallExpr] Symbol("red") | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:159:24:159:36 | [CallExpr] Symbol("red") | tst.ts:159:24:159:29 | [VarRef] Symbol | semmle.label | 0 | -| tst.ts:159:24:159:36 | [CallExpr] Symbol("red") | tst.ts:159:24:159:29 | [VarRef] Symbol | semmle.order | 0 | -| tst.ts:160:5:160:34 | [DeclStmt] const green = ... | tst.ts:160:11:160:33 | [VariableDeclarator] green = ... green"] | semmle.label | 1 | -| tst.ts:160:5:160:34 | [DeclStmt] const green = ... | tst.ts:160:11:160:33 | [VariableDeclarator] green = ... green"] | semmle.order | 1 | -| tst.ts:160:11:160:33 | [VariableDeclarator] green = ... green"] | tst.ts:160:11:160:15 | [VarDecl] green | semmle.label | 1 | -| tst.ts:160:11:160:33 | [VariableDeclarator] green = ... green"] | tst.ts:160:11:160:15 | [VarDecl] green | semmle.order | 1 | -| tst.ts:160:11:160:33 | [VariableDeclarator] green = ... green"] | tst.ts:160:19:160:33 | [IndexExpr] colors["green"] | semmle.label | 2 | -| tst.ts:160:11:160:33 | [VariableDeclarator] green = ... green"] | tst.ts:160:19:160:33 | [IndexExpr] colors["green"] | semmle.order | 2 | -| tst.ts:160:19:160:33 | [IndexExpr] colors["green"] | tst.ts:160:19:160:24 | [VarRef] colors | semmle.label | 1 | -| tst.ts:160:19:160:33 | [IndexExpr] colors["green"] | tst.ts:160:19:160:24 | [VarRef] colors | semmle.order | 1 | -| tst.ts:160:19:160:33 | [IndexExpr] colors["green"] | tst.ts:160:26:160:32 | [Literal] "green" | semmle.label | 2 | -| tst.ts:160:19:160:33 | [IndexExpr] colors["green"] | tst.ts:160:26:160:32 | [Literal] "green" | semmle.order | 2 | -| tst.ts:161:5:161:27 | [DeclStmt] const blue = ... | tst.ts:161:11:161:26 | [VariableDeclarator] blue = colors[2] | semmle.label | 1 | -| tst.ts:161:5:161:27 | [DeclStmt] const blue = ... | tst.ts:161:11:161:26 | [VariableDeclarator] blue = colors[2] | semmle.order | 1 | -| tst.ts:161:11:161:26 | [VariableDeclarator] blue = colors[2] | tst.ts:161:11:161:14 | [VarDecl] blue | semmle.label | 1 | -| tst.ts:161:11:161:26 | [VariableDeclarator] blue = colors[2] | tst.ts:161:11:161:14 | [VarDecl] blue | semmle.order | 1 | -| tst.ts:161:11:161:26 | [VariableDeclarator] blue = colors[2] | tst.ts:161:18:161:26 | [IndexExpr] colors[2] | semmle.label | 2 | -| tst.ts:161:11:161:26 | [VariableDeclarator] blue = colors[2] | tst.ts:161:18:161:26 | [IndexExpr] colors[2] | semmle.order | 2 | -| tst.ts:161:18:161:26 | [IndexExpr] colors[2] | tst.ts:161:18:161:23 | [VarRef] colors | semmle.label | 1 | -| tst.ts:161:18:161:26 | [IndexExpr] colors[2] | tst.ts:161:18:161:23 | [VarRef] colors | semmle.order | 1 | -| tst.ts:161:18:161:26 | [IndexExpr] colors[2] | tst.ts:161:25:161:25 | [Literal] 2 | semmle.label | 2 | -| tst.ts:161:18:161:26 | [IndexExpr] colors[2] | tst.ts:161:25:161:25 | [Literal] 2 | semmle.order | 2 | -| tst.ts:164:3:177:3 | [FunctionDeclStmt] functio ... "]; } | tst.ts:164:12:164:29 | [VarDecl] stringPatternIndex | semmle.label | 0 | -| tst.ts:164:3:177:3 | [FunctionDeclStmt] functio ... "]; } | tst.ts:164:12:164:29 | [VarDecl] stringPatternIndex | semmle.order | 0 | -| tst.ts:164:3:177:3 | [FunctionDeclStmt] functio ... "]; } | tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | semmle.label | 5 | -| tst.ts:164:3:177:3 | [FunctionDeclStmt] functio ... "]; } | tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | semmle.order | 5 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:165:5:167:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | semmle.label | 1 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:165:5:167:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | semmle.order | 1 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:168:5:168:23 | [DeclStmt] var bla = ... | semmle.label | 2 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:168:5:168:23 | [DeclStmt] var bla = ... | semmle.order | 2 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:169:5:169:29 | [DeclStmt] const bar = ... | semmle.label | 3 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:169:5:169:29 | [DeclStmt] const bar = ... | semmle.order | 3 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:171:5:173:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | semmle.label | 4 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:171:5:173:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | semmle.order | 4 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:175:5:175:26 | [DeclStmt] const data = ... | semmle.label | 5 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:175:5:175:26 | [DeclStmt] const data = ... | semmle.order | 5 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:176:5:176:28 | [DeclStmt] const baz = ... | semmle.label | 6 | -| tst.ts:164:33:177:3 | [BlockStmt] { i ... "]; } | tst.ts:176:5:176:28 | [DeclStmt] const baz = ... | semmle.order | 6 | -| tst.ts:165:5:167:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:165:15:165:17 | [Identifier] Foo | semmle.label | 1 | -| tst.ts:165:5:167:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:165:15:165:17 | [Identifier] Foo | semmle.order | 1 | -| tst.ts:165:5:167:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:166:7:166:37 | [IndexSignature] [key: ` ... number; | semmle.label | 2 | -| tst.ts:165:5:167:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:166:7:166:37 | [IndexSignature] [key: ` ... number; | semmle.order | 2 | -| tst.ts:166:7:166:37 | [FunctionExpr] [key: ` ... number; | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:166:7:166:37 | [FunctionExpr] [key: ` ... number; | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:166:7:166:37 | [FunctionExpr] [key: ` ... number; | tst.ts:166:31:166:36 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:166:7:166:37 | [FunctionExpr] [key: ` ... number; | tst.ts:166:31:166:36 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:166:7:166:37 | [IndexSignature] [key: ` ... number; | tst.ts:166:7:166:37 | [FunctionExpr] [key: ` ... number; | semmle.label | 1 | -| tst.ts:166:7:166:37 | [IndexSignature] [key: ` ... number; | tst.ts:166:7:166:37 | [FunctionExpr] [key: ` ... number; | semmle.order | 1 | -| tst.ts:166:8:166:10 | [SimpleParameter] key | tst.ts:166:13:166:27 | [TemplateLiteralTypeExpr] `foo-${number}` | semmle.label | -2 | -| tst.ts:166:8:166:10 | [SimpleParameter] key | tst.ts:166:13:166:27 | [TemplateLiteralTypeExpr] `foo-${number}` | semmle.order | -2 | -| tst.ts:166:13:166:27 | [TemplateLiteralTypeExpr] `foo-${number}` | tst.ts:166:14:166:17 | [LiteralTypeExpr] foo- | semmle.label | 1 | -| tst.ts:166:13:166:27 | [TemplateLiteralTypeExpr] `foo-${number}` | tst.ts:166:14:166:17 | [LiteralTypeExpr] foo- | semmle.order | 1 | -| tst.ts:166:13:166:27 | [TemplateLiteralTypeExpr] `foo-${number}` | tst.ts:166:20:166:25 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:166:13:166:27 | [TemplateLiteralTypeExpr] `foo-${number}` | tst.ts:166:20:166:25 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:168:5:168:23 | [DeclStmt] var bla = ... | tst.ts:168:9:168:22 | [VariableDeclarator] bla : Foo = {} | semmle.label | 1 | -| tst.ts:168:5:168:23 | [DeclStmt] var bla = ... | tst.ts:168:9:168:22 | [VariableDeclarator] bla : Foo = {} | semmle.order | 1 | -| tst.ts:168:9:168:22 | [VariableDeclarator] bla : Foo = {} | tst.ts:168:9:168:11 | [VarDecl] bla | semmle.label | 1 | -| tst.ts:168:9:168:22 | [VariableDeclarator] bla : Foo = {} | tst.ts:168:9:168:11 | [VarDecl] bla | semmle.order | 1 | -| tst.ts:168:9:168:22 | [VariableDeclarator] bla : Foo = {} | tst.ts:168:15:168:17 | [LocalTypeAccess] Foo | semmle.label | 2 | -| tst.ts:168:9:168:22 | [VariableDeclarator] bla : Foo = {} | tst.ts:168:15:168:17 | [LocalTypeAccess] Foo | semmle.order | 2 | -| tst.ts:168:9:168:22 | [VariableDeclarator] bla : Foo = {} | tst.ts:168:21:168:22 | [ObjectExpr] {} | semmle.label | 3 | -| tst.ts:168:9:168:22 | [VariableDeclarator] bla : Foo = {} | tst.ts:168:21:168:22 | [ObjectExpr] {} | semmle.order | 3 | -| tst.ts:169:5:169:29 | [DeclStmt] const bar = ... | tst.ts:169:11:169:28 | [VariableDeclarator] bar = bla[`foo-1`] | semmle.label | 1 | -| tst.ts:169:5:169:29 | [DeclStmt] const bar = ... | tst.ts:169:11:169:28 | [VariableDeclarator] bar = bla[`foo-1`] | semmle.order | 1 | -| tst.ts:169:11:169:28 | [VariableDeclarator] bar = bla[`foo-1`] | tst.ts:169:11:169:13 | [VarDecl] bar | semmle.label | 1 | -| tst.ts:169:11:169:28 | [VariableDeclarator] bar = bla[`foo-1`] | tst.ts:169:11:169:13 | [VarDecl] bar | semmle.order | 1 | -| tst.ts:169:11:169:28 | [VariableDeclarator] bar = bla[`foo-1`] | tst.ts:169:17:169:28 | [IndexExpr] bla[`foo-1`] | semmle.label | 2 | -| tst.ts:169:11:169:28 | [VariableDeclarator] bar = bla[`foo-1`] | tst.ts:169:17:169:28 | [IndexExpr] bla[`foo-1`] | semmle.order | 2 | -| tst.ts:169:17:169:28 | [IndexExpr] bla[`foo-1`] | tst.ts:169:17:169:19 | [VarRef] bla | semmle.label | 1 | -| tst.ts:169:17:169:28 | [IndexExpr] bla[`foo-1`] | tst.ts:169:17:169:19 | [VarRef] bla | semmle.order | 1 | -| tst.ts:169:17:169:28 | [IndexExpr] bla[`foo-1`] | tst.ts:169:21:169:27 | [TemplateLiteral] `foo-1` | semmle.label | 2 | -| tst.ts:169:17:169:28 | [IndexExpr] bla[`foo-1`] | tst.ts:169:21:169:27 | [TemplateLiteral] `foo-1` | semmle.order | 2 | -| tst.ts:169:21:169:27 | [TemplateLiteral] `foo-1` | tst.ts:169:21:169:27 | [TemplateElement] `foo-1` | semmle.label | 1 | -| tst.ts:169:21:169:27 | [TemplateLiteral] `foo-1` | tst.ts:169:21:169:27 | [TemplateElement] `foo-1` | semmle.order | 1 | -| tst.ts:171:5:173:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:171:15:171:18 | [Identifier] Data | semmle.label | 1 | -| tst.ts:171:5:173:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:171:15:171:18 | [Identifier] Data | semmle.order | 1 | -| tst.ts:171:5:173:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:172:7:172:42 | [IndexSignature] [optNam ... oolean; | semmle.label | 2 | -| tst.ts:171:5:173:5 | [InterfaceDeclaration,TypeDefinition] interfa ... ; } | tst.ts:172:7:172:42 | [IndexSignature] [optNam ... oolean; | semmle.order | 2 | -| tst.ts:172:7:172:42 | [FunctionExpr] [optNam ... oolean; | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:172:7:172:42 | [FunctionExpr] [optNam ... oolean; | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:172:7:172:42 | [FunctionExpr] [optNam ... oolean; | tst.ts:172:35:172:41 | [KeywordTypeExpr] boolean | semmle.label | 4 | -| tst.ts:172:7:172:42 | [FunctionExpr] [optNam ... oolean; | tst.ts:172:35:172:41 | [KeywordTypeExpr] boolean | semmle.order | 4 | -| tst.ts:172:7:172:42 | [IndexSignature] [optNam ... oolean; | tst.ts:172:7:172:42 | [FunctionExpr] [optNam ... oolean; | semmle.label | 1 | -| tst.ts:172:7:172:42 | [IndexSignature] [optNam ... oolean; | tst.ts:172:7:172:42 | [FunctionExpr] [optNam ... oolean; | semmle.order | 1 | -| tst.ts:172:8:172:14 | [SimpleParameter] optName | tst.ts:172:17:172:31 | [UnionTypeExpr] string \| symbol | semmle.label | -2 | -| tst.ts:172:8:172:14 | [SimpleParameter] optName | tst.ts:172:17:172:31 | [UnionTypeExpr] string \| symbol | semmle.order | -2 | -| tst.ts:172:17:172:31 | [UnionTypeExpr] string \| symbol | tst.ts:172:17:172:22 | [KeywordTypeExpr] string | semmle.label | 1 | -| tst.ts:172:17:172:31 | [UnionTypeExpr] string \| symbol | tst.ts:172:17:172:22 | [KeywordTypeExpr] string | semmle.order | 1 | -| tst.ts:172:17:172:31 | [UnionTypeExpr] string \| symbol | tst.ts:172:26:172:31 | [KeywordTypeExpr] symbol | semmle.label | 2 | -| tst.ts:172:17:172:31 | [UnionTypeExpr] string \| symbol | tst.ts:172:26:172:31 | [KeywordTypeExpr] symbol | semmle.order | 2 | -| tst.ts:175:5:175:26 | [DeclStmt] const data = ... | tst.ts:175:11:175:25 | [VariableDeclarator] data: Data = {} | semmle.label | 1 | -| tst.ts:175:5:175:26 | [DeclStmt] const data = ... | tst.ts:175:11:175:25 | [VariableDeclarator] data: Data = {} | semmle.order | 1 | -| tst.ts:175:11:175:25 | [VariableDeclarator] data: Data = {} | tst.ts:175:11:175:14 | [VarDecl] data | semmle.label | 1 | -| tst.ts:175:11:175:25 | [VariableDeclarator] data: Data = {} | tst.ts:175:11:175:14 | [VarDecl] data | semmle.order | 1 | -| tst.ts:175:11:175:25 | [VariableDeclarator] data: Data = {} | tst.ts:175:17:175:20 | [LocalTypeAccess] Data | semmle.label | 2 | -| tst.ts:175:11:175:25 | [VariableDeclarator] data: Data = {} | tst.ts:175:17:175:20 | [LocalTypeAccess] Data | semmle.order | 2 | -| tst.ts:175:11:175:25 | [VariableDeclarator] data: Data = {} | tst.ts:175:24:175:25 | [ObjectExpr] {} | semmle.label | 3 | -| tst.ts:175:11:175:25 | [VariableDeclarator] data: Data = {} | tst.ts:175:24:175:25 | [ObjectExpr] {} | semmle.order | 3 | -| tst.ts:176:5:176:28 | [DeclStmt] const baz = ... | tst.ts:176:11:176:27 | [VariableDeclarator] baz = data["foo"] | semmle.label | 1 | -| tst.ts:176:5:176:28 | [DeclStmt] const baz = ... | tst.ts:176:11:176:27 | [VariableDeclarator] baz = data["foo"] | semmle.order | 1 | -| tst.ts:176:11:176:27 | [VariableDeclarator] baz = data["foo"] | tst.ts:176:11:176:13 | [VarDecl] baz | semmle.label | 1 | -| tst.ts:176:11:176:27 | [VariableDeclarator] baz = data["foo"] | tst.ts:176:11:176:13 | [VarDecl] baz | semmle.order | 1 | -| tst.ts:176:11:176:27 | [VariableDeclarator] baz = data["foo"] | tst.ts:176:17:176:27 | [IndexExpr] data["foo"] | semmle.label | 2 | -| tst.ts:176:11:176:27 | [VariableDeclarator] baz = data["foo"] | tst.ts:176:17:176:27 | [IndexExpr] data["foo"] | semmle.order | 2 | -| tst.ts:176:17:176:27 | [IndexExpr] data["foo"] | tst.ts:176:17:176:20 | [VarRef] data | semmle.label | 1 | -| tst.ts:176:17:176:27 | [IndexExpr] data["foo"] | tst.ts:176:17:176:20 | [VarRef] data | semmle.order | 1 | -| tst.ts:176:17:176:27 | [IndexExpr] data["foo"] | tst.ts:176:22:176:26 | [Literal] "foo" | semmle.label | 2 | -| tst.ts:176:17:176:27 | [IndexExpr] data["foo"] | tst.ts:176:22:176:26 | [Literal] "foo" | semmle.order | 2 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:179:9:179:11 | [VarDecl] Foo | semmle.label | 1 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:179:9:179:11 | [VarDecl] Foo | semmle.order | 1 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:179:13:179:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | 2 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:179:13:179:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.order | 2 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:180:5:180:22 | [ClassInitializedMember,FieldDeclaration] static #count = 0; | semmle.label | 3 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:180:5:180:22 | [ClassInitializedMember,FieldDeclaration] static #count = 0; | semmle.order | 3 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:182:5:184:5 | [ClassInitializedMember,GetterMethodDefinition] get cou ... ; } | semmle.label | 4 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:182:5:184:5 | [ClassInitializedMember,GetterMethodDefinition] get cou ... ; } | semmle.order | 4 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:185:5:187:5 | [ClassInitializedMember] static ... ; } | semmle.label | 5 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:185:5:187:5 | [ClassInitializedMember] static ... ; } | semmle.order | 5 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:188:5:190:5 | [ClassInitializedMember] static ... ; } | semmle.label | 6 | -| tst.ts:179:3:192:3 | [ClassDefinition,TypeDefinition] class F ... } | tst.ts:188:5:190:5 | [ClassInitializedMember] static ... ; } | semmle.order | 6 | -| tst.ts:179:13:179:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:179:13:179:12 | [FunctionExpr] () {} | semmle.label | 2 | -| tst.ts:179:13:179:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:179:13:179:12 | [FunctionExpr] () {} | semmle.order | 2 | -| tst.ts:179:13:179:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:179:13:179:12 | [Label] constructor | semmle.label | 1 | -| tst.ts:179:13:179:12 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:179:13:179:12 | [Label] constructor | semmle.order | 1 | -| tst.ts:179:13:179:12 | [FunctionExpr] () {} | tst.ts:179:13:179:12 | [BlockStmt] {} | semmle.label | 5 | -| tst.ts:179:13:179:12 | [FunctionExpr] () {} | tst.ts:179:13:179:12 | [BlockStmt] {} | semmle.order | 5 | -| tst.ts:180:5:180:22 | [ClassInitializedMember,FieldDeclaration] static #count = 0; | tst.ts:180:12:180:17 | [Label] #count | semmle.label | 1 | -| tst.ts:180:5:180:22 | [ClassInitializedMember,FieldDeclaration] static #count = 0; | tst.ts:180:12:180:17 | [Label] #count | semmle.order | 1 | -| tst.ts:180:5:180:22 | [ClassInitializedMember,FieldDeclaration] static #count = 0; | tst.ts:180:21:180:21 | [Literal] 0 | semmle.label | 2 | -| tst.ts:180:5:180:22 | [ClassInitializedMember,FieldDeclaration] static #count = 0; | tst.ts:180:21:180:21 | [Literal] 0 | semmle.order | 2 | -| tst.ts:182:5:184:5 | [ClassInitializedMember,GetterMethodDefinition] get cou ... ; } | tst.ts:182:5:184:5 | [FunctionExpr] get cou ... ; } | semmle.label | 1 | -| tst.ts:182:5:184:5 | [ClassInitializedMember,GetterMethodDefinition] get cou ... ; } | tst.ts:182:5:184:5 | [FunctionExpr] get cou ... ; } | semmle.order | 1 | -| tst.ts:182:5:184:5 | [ClassInitializedMember,GetterMethodDefinition] get cou ... ; } | tst.ts:182:9:182:13 | [Label] count | semmle.label | 2 | -| tst.ts:182:5:184:5 | [ClassInitializedMember,GetterMethodDefinition] get cou ... ; } | tst.ts:182:9:182:13 | [Label] count | semmle.order | 2 | -| tst.ts:182:5:184:5 | [FunctionExpr] get cou ... ; } | tst.ts:182:17:184:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:182:5:184:5 | [FunctionExpr] get cou ... ; } | tst.ts:182:17:184:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:182:17:184:5 | [BlockStmt] { ... ; } | tst.ts:183:9:183:26 | [ReturnStmt] return Foo.#count; | semmle.label | 1 | -| tst.ts:182:17:184:5 | [BlockStmt] { ... ; } | tst.ts:183:9:183:26 | [ReturnStmt] return Foo.#count; | semmle.order | 1 | -| tst.ts:183:9:183:26 | [ReturnStmt] return Foo.#count; | tst.ts:183:16:183:25 | [DotExpr] Foo.#count | semmle.label | 1 | -| tst.ts:183:9:183:26 | [ReturnStmt] return Foo.#count; | tst.ts:183:16:183:25 | [DotExpr] Foo.#count | semmle.order | 1 | -| tst.ts:183:16:183:25 | [DotExpr] Foo.#count | tst.ts:183:16:183:18 | [VarRef] Foo | semmle.label | 1 | -| tst.ts:183:16:183:25 | [DotExpr] Foo.#count | tst.ts:183:16:183:18 | [VarRef] Foo | semmle.order | 1 | -| tst.ts:183:16:183:25 | [DotExpr] Foo.#count | tst.ts:183:20:183:25 | [Label] #count | semmle.label | 2 | -| tst.ts:183:16:183:25 | [DotExpr] Foo.#count | tst.ts:183:20:183:25 | [Label] #count | semmle.order | 2 | -| tst.ts:185:5:187:5 | [BlockStmt] static ... ; } | tst.ts:186:7:186:22 | [ExprStmt] Foo.#count += 3; | semmle.label | 1 | -| tst.ts:185:5:187:5 | [BlockStmt] static ... ; } | tst.ts:186:7:186:22 | [ExprStmt] Foo.#count += 3; | semmle.order | 1 | -| tst.ts:185:5:187:5 | [ClassInitializedMember] static ... ; } | tst.ts:185:5:187:5 | [BlockStmt] static ... ; } | semmle.label | 1 | -| tst.ts:185:5:187:5 | [ClassInitializedMember] static ... ; } | tst.ts:185:5:187:5 | [BlockStmt] static ... ; } | semmle.order | 1 | -| tst.ts:186:7:186:16 | [DotExpr] Foo.#count | tst.ts:186:7:186:9 | [VarRef] Foo | semmle.label | 1 | -| tst.ts:186:7:186:16 | [DotExpr] Foo.#count | tst.ts:186:7:186:9 | [VarRef] Foo | semmle.order | 1 | -| tst.ts:186:7:186:16 | [DotExpr] Foo.#count | tst.ts:186:11:186:16 | [Label] #count | semmle.label | 2 | -| tst.ts:186:7:186:16 | [DotExpr] Foo.#count | tst.ts:186:11:186:16 | [Label] #count | semmle.order | 2 | -| tst.ts:186:7:186:21 | [CompoundAssignExpr] Foo.#count += 3 | tst.ts:186:7:186:16 | [DotExpr] Foo.#count | semmle.label | 1 | -| tst.ts:186:7:186:21 | [CompoundAssignExpr] Foo.#count += 3 | tst.ts:186:7:186:16 | [DotExpr] Foo.#count | semmle.order | 1 | -| tst.ts:186:7:186:21 | [CompoundAssignExpr] Foo.#count += 3 | tst.ts:186:21:186:21 | [Literal] 3 | semmle.label | 2 | -| tst.ts:186:7:186:21 | [CompoundAssignExpr] Foo.#count += 3 | tst.ts:186:21:186:21 | [Literal] 3 | semmle.order | 2 | -| tst.ts:186:7:186:22 | [ExprStmt] Foo.#count += 3; | tst.ts:186:7:186:21 | [CompoundAssignExpr] Foo.#count += 3 | semmle.label | 1 | -| tst.ts:186:7:186:22 | [ExprStmt] Foo.#count += 3; | tst.ts:186:7:186:21 | [CompoundAssignExpr] Foo.#count += 3 | semmle.order | 1 | -| tst.ts:188:5:190:5 | [BlockStmt] static ... ; } | tst.ts:189:7:189:29 | [DeclStmt] var count = ... | semmle.label | 1 | -| tst.ts:188:5:190:5 | [BlockStmt] static ... ; } | tst.ts:189:7:189:29 | [DeclStmt] var count = ... | semmle.order | 1 | -| tst.ts:188:5:190:5 | [ClassInitializedMember] static ... ; } | tst.ts:188:5:190:5 | [BlockStmt] static ... ; } | semmle.label | 1 | -| tst.ts:188:5:190:5 | [ClassInitializedMember] static ... ; } | tst.ts:188:5:190:5 | [BlockStmt] static ... ; } | semmle.order | 1 | -| tst.ts:189:7:189:29 | [DeclStmt] var count = ... | tst.ts:189:11:189:28 | [VariableDeclarator] count = Foo.#count | semmle.label | 1 | -| tst.ts:189:7:189:29 | [DeclStmt] var count = ... | tst.ts:189:11:189:28 | [VariableDeclarator] count = Foo.#count | semmle.order | 1 | -| tst.ts:189:11:189:28 | [VariableDeclarator] count = Foo.#count | tst.ts:189:11:189:15 | [VarDecl] count | semmle.label | 1 | -| tst.ts:189:11:189:28 | [VariableDeclarator] count = Foo.#count | tst.ts:189:11:189:15 | [VarDecl] count | semmle.order | 1 | -| tst.ts:189:11:189:28 | [VariableDeclarator] count = Foo.#count | tst.ts:189:19:189:28 | [DotExpr] Foo.#count | semmle.label | 2 | -| tst.ts:189:11:189:28 | [VariableDeclarator] count = Foo.#count | tst.ts:189:19:189:28 | [DotExpr] Foo.#count | semmle.order | 2 | -| tst.ts:189:19:189:28 | [DotExpr] Foo.#count | tst.ts:189:19:189:21 | [VarRef] Foo | semmle.label | 1 | -| tst.ts:189:19:189:28 | [DotExpr] Foo.#count | tst.ts:189:19:189:21 | [VarRef] Foo | semmle.order | 1 | -| tst.ts:189:19:189:28 | [DotExpr] Foo.#count | tst.ts:189:23:189:28 | [Label] #count | semmle.label | 2 | -| tst.ts:189:19:189:28 | [DotExpr] Foo.#count | tst.ts:189:23:189:28 | [Label] #count | semmle.order | 2 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:195:8:195:11 | [VarDecl] TS45 | semmle.label | 1 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:195:8:195:11 | [VarDecl] TS45 | semmle.order | 1 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:197:3:197:36 | [TypeAliasDeclaration,TypeDefinition] type A ... ring>>; | semmle.label | 2 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:197:3:197:36 | [TypeAliasDeclaration,TypeDefinition] type A ... ring>>; | semmle.order | 2 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:200:3:200:45 | [TypeAliasDeclaration,TypeDefinition] type B ... ber>>>; | semmle.label | 3 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:200:3:200:45 | [TypeAliasDeclaration,TypeDefinition] type B ... ber>>>; | semmle.order | 3 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:203:3:203:46 | [TypeAliasDeclaration,TypeDefinition] type C ... mber>>; | semmle.label | 4 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:203:3:203:46 | [TypeAliasDeclaration,TypeDefinition] type C ... mber>>; | semmle.order | 4 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:205:3:208:3 | [ExportDeclaration] export ... ng; } | semmle.label | 5 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:205:3:208:3 | [ExportDeclaration] export ... ng; } | semmle.order | 5 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:210:3:213:3 | [ExportDeclaration] export ... ng; } | semmle.label | 6 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:210:3:213:3 | [ExportDeclaration] export ... ng; } | semmle.order | 6 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:215:3:220:3 | [ExportDeclaration] export ... } } | semmle.label | 7 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:215:3:220:3 | [ExportDeclaration] export ... } } | semmle.order | 7 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | semmle.label | 8 | -| tst.ts:195:1:235:1 | [NamespaceDeclaration] module ... } } } | tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | semmle.order | 8 | -| tst.ts:197:3:197:36 | [TypeAliasDeclaration,TypeDefinition] type A ... ring>>; | tst.ts:197:8:197:8 | [Identifier] A | semmle.label | 1 | -| tst.ts:197:3:197:36 | [TypeAliasDeclaration,TypeDefinition] type A ... ring>>; | tst.ts:197:8:197:8 | [Identifier] A | semmle.order | 1 | -| tst.ts:197:3:197:36 | [TypeAliasDeclaration,TypeDefinition] type A ... ring>>; | tst.ts:197:12:197:35 | [GenericTypeExpr] Awaited ... tring>> | semmle.label | 2 | -| tst.ts:197:3:197:36 | [TypeAliasDeclaration,TypeDefinition] type A ... ring>>; | tst.ts:197:12:197:35 | [GenericTypeExpr] Awaited ... tring>> | semmle.order | 2 | -| tst.ts:197:12:197:35 | [GenericTypeExpr] Awaited ... tring>> | tst.ts:197:12:197:18 | [LocalTypeAccess] Awaited | semmle.label | 1 | -| tst.ts:197:12:197:35 | [GenericTypeExpr] Awaited ... tring>> | tst.ts:197:12:197:18 | [LocalTypeAccess] Awaited | semmle.order | 1 | -| tst.ts:197:12:197:35 | [GenericTypeExpr] Awaited ... tring>> | tst.ts:197:20:197:34 | [GenericTypeExpr] Promise | semmle.label | 2 | -| tst.ts:197:12:197:35 | [GenericTypeExpr] Awaited ... tring>> | tst.ts:197:20:197:34 | [GenericTypeExpr] Promise | semmle.order | 2 | -| tst.ts:197:20:197:34 | [GenericTypeExpr] Promise | tst.ts:197:20:197:26 | [LocalTypeAccess] Promise | semmle.label | 1 | -| tst.ts:197:20:197:34 | [GenericTypeExpr] Promise | tst.ts:197:20:197:26 | [LocalTypeAccess] Promise | semmle.order | 1 | -| tst.ts:197:20:197:34 | [GenericTypeExpr] Promise | tst.ts:197:28:197:33 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:197:20:197:34 | [GenericTypeExpr] Promise | tst.ts:197:28:197:33 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:200:3:200:45 | [TypeAliasDeclaration,TypeDefinition] type B ... ber>>>; | tst.ts:200:8:200:8 | [Identifier] B | semmle.label | 1 | -| tst.ts:200:3:200:45 | [TypeAliasDeclaration,TypeDefinition] type B ... ber>>>; | tst.ts:200:8:200:8 | [Identifier] B | semmle.order | 1 | -| tst.ts:200:3:200:45 | [TypeAliasDeclaration,TypeDefinition] type B ... ber>>>; | tst.ts:200:12:200:44 | [GenericTypeExpr] Awaited ... mber>>> | semmle.label | 2 | -| tst.ts:200:3:200:45 | [TypeAliasDeclaration,TypeDefinition] type B ... ber>>>; | tst.ts:200:12:200:44 | [GenericTypeExpr] Awaited ... mber>>> | semmle.order | 2 | -| tst.ts:200:12:200:44 | [GenericTypeExpr] Awaited ... mber>>> | tst.ts:200:12:200:18 | [LocalTypeAccess] Awaited | semmle.label | 1 | -| tst.ts:200:12:200:44 | [GenericTypeExpr] Awaited ... mber>>> | tst.ts:200:12:200:18 | [LocalTypeAccess] Awaited | semmle.order | 1 | -| tst.ts:200:12:200:44 | [GenericTypeExpr] Awaited ... mber>>> | tst.ts:200:20:200:43 | [GenericTypeExpr] Promise ... umber>> | semmle.label | 2 | -| tst.ts:200:12:200:44 | [GenericTypeExpr] Awaited ... mber>>> | tst.ts:200:20:200:43 | [GenericTypeExpr] Promise ... umber>> | semmle.order | 2 | -| tst.ts:200:20:200:43 | [GenericTypeExpr] Promise ... umber>> | tst.ts:200:20:200:26 | [LocalTypeAccess] Promise | semmle.label | 1 | -| tst.ts:200:20:200:43 | [GenericTypeExpr] Promise ... umber>> | tst.ts:200:20:200:26 | [LocalTypeAccess] Promise | semmle.order | 1 | -| tst.ts:200:20:200:43 | [GenericTypeExpr] Promise ... umber>> | tst.ts:200:28:200:42 | [GenericTypeExpr] Promise | semmle.label | 2 | -| tst.ts:200:20:200:43 | [GenericTypeExpr] Promise ... umber>> | tst.ts:200:28:200:42 | [GenericTypeExpr] Promise | semmle.order | 2 | -| tst.ts:200:28:200:42 | [GenericTypeExpr] Promise | tst.ts:200:28:200:34 | [LocalTypeAccess] Promise | semmle.label | 1 | -| tst.ts:200:28:200:42 | [GenericTypeExpr] Promise | tst.ts:200:28:200:34 | [LocalTypeAccess] Promise | semmle.order | 1 | -| tst.ts:200:28:200:42 | [GenericTypeExpr] Promise | tst.ts:200:36:200:41 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:200:28:200:42 | [GenericTypeExpr] Promise | tst.ts:200:36:200:41 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:203:3:203:46 | [TypeAliasDeclaration,TypeDefinition] type C ... mber>>; | tst.ts:203:8:203:8 | [Identifier] C | semmle.label | 1 | -| tst.ts:203:3:203:46 | [TypeAliasDeclaration,TypeDefinition] type C ... mber>>; | tst.ts:203:8:203:8 | [Identifier] C | semmle.order | 1 | -| tst.ts:203:3:203:46 | [TypeAliasDeclaration,TypeDefinition] type C ... mber>>; | tst.ts:203:12:203:45 | [GenericTypeExpr] Awaited ... umber>> | semmle.label | 2 | -| tst.ts:203:3:203:46 | [TypeAliasDeclaration,TypeDefinition] type C ... mber>>; | tst.ts:203:12:203:45 | [GenericTypeExpr] Awaited ... umber>> | semmle.order | 2 | -| tst.ts:203:12:203:45 | [GenericTypeExpr] Awaited ... umber>> | tst.ts:203:12:203:18 | [LocalTypeAccess] Awaited | semmle.label | 1 | -| tst.ts:203:12:203:45 | [GenericTypeExpr] Awaited ... umber>> | tst.ts:203:12:203:18 | [LocalTypeAccess] Awaited | semmle.order | 1 | -| tst.ts:203:12:203:45 | [GenericTypeExpr] Awaited ... umber>> | tst.ts:203:20:203:44 | [UnionTypeExpr] boolean ... number> | semmle.label | 2 | -| tst.ts:203:12:203:45 | [GenericTypeExpr] Awaited ... umber>> | tst.ts:203:20:203:44 | [UnionTypeExpr] boolean ... number> | semmle.order | 2 | -| tst.ts:203:20:203:44 | [UnionTypeExpr] boolean ... number> | tst.ts:203:20:203:26 | [KeywordTypeExpr] boolean | semmle.label | 1 | -| tst.ts:203:20:203:44 | [UnionTypeExpr] boolean ... number> | tst.ts:203:20:203:26 | [KeywordTypeExpr] boolean | semmle.order | 1 | -| tst.ts:203:20:203:44 | [UnionTypeExpr] boolean ... number> | tst.ts:203:30:203:44 | [GenericTypeExpr] Promise | semmle.label | 2 | -| tst.ts:203:20:203:44 | [UnionTypeExpr] boolean ... number> | tst.ts:203:30:203:44 | [GenericTypeExpr] Promise | semmle.order | 2 | -| tst.ts:203:30:203:44 | [GenericTypeExpr] Promise | tst.ts:203:30:203:36 | [LocalTypeAccess] Promise | semmle.label | 1 | -| tst.ts:203:30:203:44 | [GenericTypeExpr] Promise | tst.ts:203:30:203:36 | [LocalTypeAccess] Promise | semmle.order | 1 | -| tst.ts:203:30:203:44 | [GenericTypeExpr] Promise | tst.ts:203:38:203:43 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:203:30:203:44 | [GenericTypeExpr] Promise | tst.ts:203:38:203:43 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:205:3:208:3 | [ExportDeclaration] export ... ng; } | tst.ts:205:10:208:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | semmle.label | 1 | -| tst.ts:205:3:208:3 | [ExportDeclaration] export ... ng; } | tst.ts:205:10:208:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | semmle.order | 1 | -| tst.ts:205:10:208:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:205:20:205:26 | [Identifier] Success | semmle.label | 1 | -| tst.ts:205:10:208:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:205:20:205:26 | [Identifier] Success | semmle.order | 1 | -| tst.ts:205:10:208:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:206:5:206:29 | [FieldDeclaration] type: ` ... ccess`; | semmle.label | 2 | -| tst.ts:205:10:208:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:206:5:206:29 | [FieldDeclaration] type: ` ... ccess`; | semmle.order | 2 | -| tst.ts:205:10:208:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:207:5:207:17 | [FieldDeclaration] body: string; | semmle.label | 3 | -| tst.ts:205:10:208:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:207:5:207:17 | [FieldDeclaration] body: string; | semmle.order | 3 | -| tst.ts:206:5:206:29 | [FieldDeclaration] type: ` ... ccess`; | tst.ts:206:5:206:8 | [Label] type | semmle.label | 1 | -| tst.ts:206:5:206:29 | [FieldDeclaration] type: ` ... ccess`; | tst.ts:206:5:206:8 | [Label] type | semmle.order | 1 | -| tst.ts:206:5:206:29 | [FieldDeclaration] type: ` ... ccess`; | tst.ts:206:11:206:28 | [TemplateLiteralTypeExpr] `${string}Success` | semmle.label | 2 | -| tst.ts:206:5:206:29 | [FieldDeclaration] type: ` ... ccess`; | tst.ts:206:11:206:28 | [TemplateLiteralTypeExpr] `${string}Success` | semmle.order | 2 | -| tst.ts:206:11:206:28 | [TemplateLiteralTypeExpr] `${string}Success` | tst.ts:206:14:206:19 | [KeywordTypeExpr] string | semmle.label | 1 | -| tst.ts:206:11:206:28 | [TemplateLiteralTypeExpr] `${string}Success` | tst.ts:206:14:206:19 | [KeywordTypeExpr] string | semmle.order | 1 | -| tst.ts:206:11:206:28 | [TemplateLiteralTypeExpr] `${string}Success` | tst.ts:206:21:206:27 | [LiteralTypeExpr] Success | semmle.label | 2 | -| tst.ts:206:11:206:28 | [TemplateLiteralTypeExpr] `${string}Success` | tst.ts:206:21:206:27 | [LiteralTypeExpr] Success | semmle.order | 2 | -| tst.ts:207:5:207:17 | [FieldDeclaration] body: string; | tst.ts:207:5:207:8 | [Label] body | semmle.label | 1 | -| tst.ts:207:5:207:17 | [FieldDeclaration] body: string; | tst.ts:207:5:207:8 | [Label] body | semmle.order | 1 | -| tst.ts:207:5:207:17 | [FieldDeclaration] body: string; | tst.ts:207:11:207:16 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:207:5:207:17 | [FieldDeclaration] body: string; | tst.ts:207:11:207:16 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:210:3:213:3 | [ExportDeclaration] export ... ng; } | tst.ts:210:10:213:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | semmle.label | 1 | -| tst.ts:210:3:213:3 | [ExportDeclaration] export ... ng; } | tst.ts:210:10:213:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | semmle.order | 1 | -| tst.ts:210:10:213:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:210:20:210:24 | [Identifier] Error | semmle.label | 1 | -| tst.ts:210:10:213:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:210:20:210:24 | [Identifier] Error | semmle.order | 1 | -| tst.ts:210:10:213:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:211:7:211:29 | [FieldDeclaration] type: ` ... Error`; | semmle.label | 2 | -| tst.ts:210:10:213:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:211:7:211:29 | [FieldDeclaration] type: ` ... Error`; | semmle.order | 2 | -| tst.ts:210:10:213:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:212:7:212:22 | [FieldDeclaration] message: string; | semmle.label | 3 | -| tst.ts:210:10:213:3 | [InterfaceDeclaration,TypeDefinition] interfa ... ng; } | tst.ts:212:7:212:22 | [FieldDeclaration] message: string; | semmle.order | 3 | -| tst.ts:211:7:211:29 | [FieldDeclaration] type: ` ... Error`; | tst.ts:211:7:211:10 | [Label] type | semmle.label | 1 | -| tst.ts:211:7:211:29 | [FieldDeclaration] type: ` ... Error`; | tst.ts:211:7:211:10 | [Label] type | semmle.order | 1 | -| tst.ts:211:7:211:29 | [FieldDeclaration] type: ` ... Error`; | tst.ts:211:13:211:28 | [TemplateLiteralTypeExpr] `${string}Error` | semmle.label | 2 | -| tst.ts:211:7:211:29 | [FieldDeclaration] type: ` ... Error`; | tst.ts:211:13:211:28 | [TemplateLiteralTypeExpr] `${string}Error` | semmle.order | 2 | -| tst.ts:211:13:211:28 | [TemplateLiteralTypeExpr] `${string}Error` | tst.ts:211:16:211:21 | [KeywordTypeExpr] string | semmle.label | 1 | -| tst.ts:211:13:211:28 | [TemplateLiteralTypeExpr] `${string}Error` | tst.ts:211:16:211:21 | [KeywordTypeExpr] string | semmle.order | 1 | -| tst.ts:211:13:211:28 | [TemplateLiteralTypeExpr] `${string}Error` | tst.ts:211:23:211:27 | [LiteralTypeExpr] Error | semmle.label | 2 | -| tst.ts:211:13:211:28 | [TemplateLiteralTypeExpr] `${string}Error` | tst.ts:211:23:211:27 | [LiteralTypeExpr] Error | semmle.order | 2 | -| tst.ts:212:7:212:22 | [FieldDeclaration] message: string; | tst.ts:212:7:212:13 | [Label] message | semmle.label | 1 | -| tst.ts:212:7:212:22 | [FieldDeclaration] message: string; | tst.ts:212:7:212:13 | [Label] message | semmle.order | 1 | -| tst.ts:212:7:212:22 | [FieldDeclaration] message: string; | tst.ts:212:16:212:21 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:212:7:212:22 | [FieldDeclaration] message: string; | tst.ts:212:16:212:21 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:215:3:220:3 | [ExportDeclaration] export ... } } | tst.ts:215:10:220:3 | [FunctionDeclStmt] functio ... } } | semmle.label | 1 | -| tst.ts:215:3:220:3 | [ExportDeclaration] export ... } } | tst.ts:215:10:220:3 | [FunctionDeclStmt] functio ... } } | semmle.order | 1 | -| tst.ts:215:10:220:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:215:10:220:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:215:10:220:3 | [FunctionDeclStmt] functio ... } } | tst.ts:215:19:215:25 | [VarDecl] handler | semmle.label | 0 | -| tst.ts:215:10:220:3 | [FunctionDeclStmt] functio ... } } | tst.ts:215:19:215:25 | [VarDecl] handler | semmle.order | 0 | -| tst.ts:215:10:220:3 | [FunctionDeclStmt] functio ... } } | tst.ts:215:47:220:3 | [BlockStmt] { ... } } | semmle.label | 5 | -| tst.ts:215:10:220:3 | [FunctionDeclStmt] functio ... } } | tst.ts:215:47:220:3 | [BlockStmt] { ... } } | semmle.order | 5 | -| tst.ts:215:27:215:27 | [SimpleParameter] r | tst.ts:215:30:215:44 | [UnionTypeExpr] Success \| Error | semmle.label | -2 | -| tst.ts:215:27:215:27 | [SimpleParameter] r | tst.ts:215:30:215:44 | [UnionTypeExpr] Success \| Error | semmle.order | -2 | -| tst.ts:215:30:215:44 | [UnionTypeExpr] Success \| Error | tst.ts:215:30:215:36 | [LocalTypeAccess] Success | semmle.label | 1 | -| tst.ts:215:30:215:44 | [UnionTypeExpr] Success \| Error | tst.ts:215:30:215:36 | [LocalTypeAccess] Success | semmle.order | 1 | -| tst.ts:215:30:215:44 | [UnionTypeExpr] Success \| Error | tst.ts:215:40:215:44 | [LocalTypeAccess] Error | semmle.label | 2 | -| tst.ts:215:30:215:44 | [UnionTypeExpr] Success \| Error | tst.ts:215:40:215:44 | [LocalTypeAccess] Error | semmle.order | 2 | -| tst.ts:215:47:220:3 | [BlockStmt] { ... } } | tst.ts:216:7:219:7 | [IfStmt] if (r.t ... } | semmle.label | 1 | -| tst.ts:215:47:220:3 | [BlockStmt] { ... } } | tst.ts:216:7:219:7 | [IfStmt] if (r.t ... } | semmle.order | 1 | -| tst.ts:216:7:219:7 | [IfStmt] if (r.t ... } | tst.ts:216:11:216:34 | [BinaryExpr] r.type ... uccess" | semmle.label | 1 | -| tst.ts:216:7:219:7 | [IfStmt] if (r.t ... } | tst.ts:216:11:216:34 | [BinaryExpr] r.type ... uccess" | semmle.order | 1 | -| tst.ts:216:7:219:7 | [IfStmt] if (r.t ... } | tst.ts:216:37:219:7 | [BlockStmt] { ... } | semmle.label | 2 | -| tst.ts:216:7:219:7 | [IfStmt] if (r.t ... } | tst.ts:216:37:219:7 | [BlockStmt] { ... } | semmle.order | 2 | -| tst.ts:216:11:216:16 | [DotExpr] r.type | tst.ts:216:11:216:11 | [VarRef] r | semmle.label | 1 | -| tst.ts:216:11:216:16 | [DotExpr] r.type | tst.ts:216:11:216:11 | [VarRef] r | semmle.order | 1 | -| tst.ts:216:11:216:16 | [DotExpr] r.type | tst.ts:216:13:216:16 | [Label] type | semmle.label | 2 | -| tst.ts:216:11:216:16 | [DotExpr] r.type | tst.ts:216:13:216:16 | [Label] type | semmle.order | 2 | -| tst.ts:216:11:216:34 | [BinaryExpr] r.type ... uccess" | tst.ts:216:11:216:16 | [DotExpr] r.type | semmle.label | 1 | -| tst.ts:216:11:216:34 | [BinaryExpr] r.type ... uccess" | tst.ts:216:11:216:16 | [DotExpr] r.type | semmle.order | 1 | -| tst.ts:216:11:216:34 | [BinaryExpr] r.type ... uccess" | tst.ts:216:22:216:34 | [Literal] "HttpSuccess" | semmle.label | 2 | -| tst.ts:216:11:216:34 | [BinaryExpr] r.type ... uccess" | tst.ts:216:22:216:34 | [Literal] "HttpSuccess" | semmle.order | 2 | -| tst.ts:216:37:219:7 | [BlockStmt] { ... } | tst.ts:218:11:218:29 | [DeclStmt] let token = ... | semmle.label | 1 | -| tst.ts:216:37:219:7 | [BlockStmt] { ... } | tst.ts:218:11:218:29 | [DeclStmt] let token = ... | semmle.order | 1 | -| tst.ts:218:11:218:29 | [DeclStmt] let token = ... | tst.ts:218:15:218:28 | [VariableDeclarator] token = r.body | semmle.label | 1 | -| tst.ts:218:11:218:29 | [DeclStmt] let token = ... | tst.ts:218:15:218:28 | [VariableDeclarator] token = r.body | semmle.order | 1 | -| tst.ts:218:15:218:28 | [VariableDeclarator] token = r.body | tst.ts:218:15:218:19 | [VarDecl] token | semmle.label | 1 | -| tst.ts:218:15:218:28 | [VariableDeclarator] token = r.body | tst.ts:218:15:218:19 | [VarDecl] token | semmle.order | 1 | -| tst.ts:218:15:218:28 | [VariableDeclarator] token = r.body | tst.ts:218:23:218:28 | [DotExpr] r.body | semmle.label | 2 | -| tst.ts:218:15:218:28 | [VariableDeclarator] token = r.body | tst.ts:218:23:218:28 | [DotExpr] r.body | semmle.order | 2 | -| tst.ts:218:23:218:28 | [DotExpr] r.body | tst.ts:218:23:218:23 | [VarRef] r | semmle.label | 1 | -| tst.ts:218:23:218:28 | [DotExpr] r.body | tst.ts:218:23:218:23 | [VarRef] r | semmle.order | 1 | -| tst.ts:218:23:218:28 | [DotExpr] r.body | tst.ts:218:25:218:28 | [Label] body | semmle.label | 2 | -| tst.ts:218:23:218:28 | [DotExpr] r.body | tst.ts:218:25:218:28 | [Label] body | semmle.order | 2 | -| tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:222:9:222:14 | [VarDecl] Person | semmle.label | 1 | -| tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:222:9:222:14 | [VarDecl] Person | semmle.order | 1 | -| tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:223:5:223:18 | [FieldDeclaration] #name: string; | semmle.label | 2 | -| tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:223:5:223:18 | [FieldDeclaration] #name: string; | semmle.order | 2 | -| tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:224:5:226:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | semmle.label | 3 | -| tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:224:5:226:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | semmle.order | 3 | -| tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:228:5:233:5 | [ClassInitializedMember,MethodDefinition] equals( ... . } | semmle.label | 4 | -| tst.ts:222:3:234:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:228:5:233:5 | [ClassInitializedMember,MethodDefinition] equals( ... . } | semmle.order | 4 | -| tst.ts:223:5:223:18 | [FieldDeclaration] #name: string; | tst.ts:223:5:223:9 | [Label] #name | semmle.label | 1 | -| tst.ts:223:5:223:18 | [FieldDeclaration] #name: string; | tst.ts:223:5:223:9 | [Label] #name | semmle.order | 1 | -| tst.ts:223:5:223:18 | [FieldDeclaration] #name: string; | tst.ts:223:12:223:17 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:223:5:223:18 | [FieldDeclaration] #name: string; | tst.ts:223:12:223:17 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:224:5:226:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:224:5:226:5 | [FunctionExpr] constru ... ; } | semmle.label | 2 | -| tst.ts:224:5:226:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:224:5:226:5 | [FunctionExpr] constru ... ; } | semmle.order | 2 | -| tst.ts:224:5:226:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:224:5:226:5 | [Label] constructor | semmle.label | 1 | -| tst.ts:224:5:226:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:224:5:226:5 | [Label] constructor | semmle.order | 1 | -| tst.ts:224:5:226:5 | [FunctionExpr] constru ... ; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:224:5:226:5 | [FunctionExpr] constru ... ; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:224:5:226:5 | [FunctionExpr] constru ... ; } | tst.ts:224:31:226:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:224:5:226:5 | [FunctionExpr] constru ... ; } | tst.ts:224:31:226:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:224:17:224:20 | [SimpleParameter] name | tst.ts:224:23:224:28 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:224:17:224:20 | [SimpleParameter] name | tst.ts:224:23:224:28 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:224:31:226:5 | [BlockStmt] { ... ; } | tst.ts:225:9:225:26 | [ExprStmt] this.#name = name; | semmle.label | 1 | -| tst.ts:224:31:226:5 | [BlockStmt] { ... ; } | tst.ts:225:9:225:26 | [ExprStmt] this.#name = name; | semmle.order | 1 | -| tst.ts:225:9:225:18 | [DotExpr] this.#name | tst.ts:225:9:225:12 | [ThisExpr] this | semmle.label | 1 | -| tst.ts:225:9:225:18 | [DotExpr] this.#name | tst.ts:225:9:225:12 | [ThisExpr] this | semmle.order | 1 | -| tst.ts:225:9:225:18 | [DotExpr] this.#name | tst.ts:225:14:225:18 | [Label] #name | semmle.label | 2 | -| tst.ts:225:9:225:18 | [DotExpr] this.#name | tst.ts:225:14:225:18 | [Label] #name | semmle.order | 2 | -| tst.ts:225:9:225:25 | [AssignExpr] this.#name = name | tst.ts:225:9:225:18 | [DotExpr] this.#name | semmle.label | 1 | -| tst.ts:225:9:225:25 | [AssignExpr] this.#name = name | tst.ts:225:9:225:18 | [DotExpr] this.#name | semmle.order | 1 | -| tst.ts:225:9:225:25 | [AssignExpr] this.#name = name | tst.ts:225:22:225:25 | [VarRef] name | semmle.label | 2 | -| tst.ts:225:9:225:25 | [AssignExpr] this.#name = name | tst.ts:225:22:225:25 | [VarRef] name | semmle.order | 2 | -| tst.ts:225:9:225:26 | [ExprStmt] this.#name = name; | tst.ts:225:9:225:25 | [AssignExpr] this.#name = name | semmle.label | 1 | -| tst.ts:225:9:225:26 | [ExprStmt] this.#name = name; | tst.ts:225:9:225:25 | [AssignExpr] this.#name = name | semmle.order | 1 | -| tst.ts:228:5:233:5 | [ClassInitializedMember,MethodDefinition] equals( ... . } | tst.ts:228:5:228:10 | [Label] equals | semmle.label | 1 | -| tst.ts:228:5:233:5 | [ClassInitializedMember,MethodDefinition] equals( ... . } | tst.ts:228:5:228:10 | [Label] equals | semmle.order | 1 | -| tst.ts:228:5:233:5 | [ClassInitializedMember,MethodDefinition] equals( ... . } | tst.ts:228:5:233:5 | [FunctionExpr] equals( ... . } | semmle.label | 2 | -| tst.ts:228:5:233:5 | [ClassInitializedMember,MethodDefinition] equals( ... . } | tst.ts:228:5:233:5 | [FunctionExpr] equals( ... . } | semmle.order | 2 | -| tst.ts:228:5:233:5 | [FunctionExpr] equals( ... . } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:228:5:233:5 | [FunctionExpr] equals( ... . } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:228:5:233:5 | [FunctionExpr] equals( ... . } | tst.ts:228:28:233:5 | [BlockStmt] { ... . } | semmle.label | 5 | -| tst.ts:228:5:233:5 | [FunctionExpr] equals( ... . } | tst.ts:228:28:233:5 | [BlockStmt] { ... . } | semmle.order | 5 | -| tst.ts:228:12:228:16 | [SimpleParameter] other | tst.ts:228:19:228:25 | [KeywordTypeExpr] unknown | semmle.label | -2 | -| tst.ts:228:12:228:16 | [SimpleParameter] other | tst.ts:228:19:228:25 | [KeywordTypeExpr] unknown | semmle.order | -2 | -| tst.ts:228:28:233:5 | [BlockStmt] { ... . } | tst.ts:229:9:232:39 | [ReturnStmt] return ... .#name; | semmle.label | 1 | -| tst.ts:228:28:233:5 | [BlockStmt] { ... . } | tst.ts:229:9:232:39 | [ReturnStmt] return ... .#name; | semmle.order | 1 | -| tst.ts:229:9:232:39 | [ReturnStmt] return ... .#name; | tst.ts:229:16:232:38 | [BinaryExpr] other & ... r.#name | semmle.label | 1 | -| tst.ts:229:9:232:39 | [ReturnStmt] return ... .#name; | tst.ts:229:16:232:38 | [BinaryExpr] other & ... r.#name | semmle.order | 1 | -| tst.ts:229:16:230:37 | [BinaryExpr] other & ... object" | tst.ts:229:16:229:20 | [VarRef] other | semmle.label | 1 | -| tst.ts:229:16:230:37 | [BinaryExpr] other & ... object" | tst.ts:229:16:229:20 | [VarRef] other | semmle.order | 1 | -| tst.ts:229:16:230:37 | [BinaryExpr] other & ... object" | tst.ts:230:13:230:37 | [BinaryExpr] typeof ... object" | semmle.label | 2 | -| tst.ts:229:16:230:37 | [BinaryExpr] other & ... object" | tst.ts:230:13:230:37 | [BinaryExpr] typeof ... object" | semmle.order | 2 | -| tst.ts:229:16:231:26 | [BinaryExpr] other & ... n other | tst.ts:229:16:230:37 | [BinaryExpr] other & ... object" | semmle.label | 1 | -| tst.ts:229:16:231:26 | [BinaryExpr] other & ... n other | tst.ts:229:16:230:37 | [BinaryExpr] other & ... object" | semmle.order | 1 | -| tst.ts:229:16:231:26 | [BinaryExpr] other & ... n other | tst.ts:231:13:231:26 | [BinaryExpr] #name in other | semmle.label | 2 | -| tst.ts:229:16:231:26 | [BinaryExpr] other & ... n other | tst.ts:231:13:231:26 | [BinaryExpr] #name in other | semmle.order | 2 | -| tst.ts:229:16:232:38 | [BinaryExpr] other & ... r.#name | tst.ts:229:16:231:26 | [BinaryExpr] other & ... n other | semmle.label | 1 | -| tst.ts:229:16:232:38 | [BinaryExpr] other & ... r.#name | tst.ts:229:16:231:26 | [BinaryExpr] other & ... n other | semmle.order | 1 | -| tst.ts:229:16:232:38 | [BinaryExpr] other & ... r.#name | tst.ts:232:13:232:38 | [BinaryExpr] this.#n ... r.#name | semmle.label | 2 | -| tst.ts:229:16:232:38 | [BinaryExpr] other & ... r.#name | tst.ts:232:13:232:38 | [BinaryExpr] this.#n ... r.#name | semmle.order | 2 | -| tst.ts:230:13:230:24 | [UnaryExpr] typeof other | tst.ts:230:20:230:24 | [VarRef] other | semmle.label | 1 | -| tst.ts:230:13:230:24 | [UnaryExpr] typeof other | tst.ts:230:20:230:24 | [VarRef] other | semmle.order | 1 | -| tst.ts:230:13:230:37 | [BinaryExpr] typeof ... object" | tst.ts:230:13:230:24 | [UnaryExpr] typeof other | semmle.label | 1 | -| tst.ts:230:13:230:37 | [BinaryExpr] typeof ... object" | tst.ts:230:13:230:24 | [UnaryExpr] typeof other | semmle.order | 1 | -| tst.ts:230:13:230:37 | [BinaryExpr] typeof ... object" | tst.ts:230:30:230:37 | [Literal] "object" | semmle.label | 2 | -| tst.ts:230:13:230:37 | [BinaryExpr] typeof ... object" | tst.ts:230:30:230:37 | [Literal] "object" | semmle.order | 2 | -| tst.ts:231:13:231:26 | [BinaryExpr] #name in other | tst.ts:231:13:231:17 | [Label] #name | semmle.label | 1 | -| tst.ts:231:13:231:26 | [BinaryExpr] #name in other | tst.ts:231:13:231:17 | [Label] #name | semmle.order | 1 | -| tst.ts:231:13:231:26 | [BinaryExpr] #name in other | tst.ts:231:22:231:26 | [VarRef] other | semmle.label | 2 | -| tst.ts:231:13:231:26 | [BinaryExpr] #name in other | tst.ts:231:22:231:26 | [VarRef] other | semmle.order | 2 | -| tst.ts:232:13:232:22 | [DotExpr] this.#name | tst.ts:232:13:232:16 | [ThisExpr] this | semmle.label | 1 | -| tst.ts:232:13:232:22 | [DotExpr] this.#name | tst.ts:232:13:232:16 | [ThisExpr] this | semmle.order | 1 | -| tst.ts:232:13:232:22 | [DotExpr] this.#name | tst.ts:232:18:232:22 | [Label] #name | semmle.label | 2 | -| tst.ts:232:13:232:22 | [DotExpr] this.#name | tst.ts:232:18:232:22 | [Label] #name | semmle.order | 2 | -| tst.ts:232:13:232:38 | [BinaryExpr] this.#n ... r.#name | tst.ts:232:13:232:22 | [DotExpr] this.#name | semmle.label | 1 | -| tst.ts:232:13:232:38 | [BinaryExpr] this.#n ... r.#name | tst.ts:232:13:232:22 | [DotExpr] this.#name | semmle.order | 1 | -| tst.ts:232:13:232:38 | [BinaryExpr] this.#n ... r.#name | tst.ts:232:28:232:38 | [DotExpr] other.#name | semmle.label | 2 | -| tst.ts:232:13:232:38 | [BinaryExpr] this.#n ... r.#name | tst.ts:232:28:232:38 | [DotExpr] other.#name | semmle.order | 2 | -| tst.ts:232:28:232:38 | [DotExpr] other.#name | tst.ts:232:28:232:32 | [VarRef] other | semmle.label | 1 | -| tst.ts:232:28:232:38 | [DotExpr] other.#name | tst.ts:232:28:232:32 | [VarRef] other | semmle.order | 1 | -| tst.ts:232:28:232:38 | [DotExpr] other.#name | tst.ts:232:34:232:38 | [Label] #name | semmle.label | 2 | -| tst.ts:232:28:232:38 | [DotExpr] other.#name | tst.ts:232:34:232:38 | [Label] #name | semmle.order | 2 | -| tst.ts:237:1:237:63 | [ImportDeclaration] import ... son" }; | tst.ts:237:8:237:16 | [ImportSpecifier] * as Foo3 | semmle.label | 1 | -| tst.ts:237:1:237:63 | [ImportDeclaration] import ... son" }; | tst.ts:237:8:237:16 | [ImportSpecifier] * as Foo3 | semmle.order | 1 | -| tst.ts:237:1:237:63 | [ImportDeclaration] import ... son" }; | tst.ts:237:23:237:40 | [Literal] "./something.json" | semmle.label | 2 | -| tst.ts:237:1:237:63 | [ImportDeclaration] import ... son" }; | tst.ts:237:23:237:40 | [Literal] "./something.json" | semmle.order | 2 | -| tst.ts:237:1:237:63 | [ImportDeclaration] import ... son" }; | tst.ts:237:47:237:62 | [ObjectExpr] { type: "json" } | semmle.label | 3 | -| tst.ts:237:1:237:63 | [ImportDeclaration] import ... son" }; | tst.ts:237:47:237:62 | [ObjectExpr] { type: "json" } | semmle.order | 3 | -| tst.ts:237:8:237:16 | [ImportSpecifier] * as Foo3 | tst.ts:237:13:237:16 | [VarDecl] Foo3 | semmle.label | 1 | -| tst.ts:237:8:237:16 | [ImportSpecifier] * as Foo3 | tst.ts:237:13:237:16 | [VarDecl] Foo3 | semmle.order | 1 | -| tst.ts:237:47:237:62 | [ObjectExpr] { type: "json" } | tst.ts:237:49:237:60 | [Property] type: "json" | semmle.label | 1 | -| tst.ts:237:47:237:62 | [ObjectExpr] { type: "json" } | tst.ts:237:49:237:60 | [Property] type: "json" | semmle.order | 1 | -| tst.ts:238:1:238:19 | [DeclStmt] var foo = ... | tst.ts:238:5:238:18 | [VariableDeclarator] foo = Foo3.foo | semmle.label | 1 | -| tst.ts:238:1:238:19 | [DeclStmt] var foo = ... | tst.ts:238:5:238:18 | [VariableDeclarator] foo = Foo3.foo | semmle.order | 1 | -| tst.ts:238:5:238:18 | [VariableDeclarator] foo = Foo3.foo | tst.ts:238:5:238:7 | [VarDecl] foo | semmle.label | 1 | -| tst.ts:238:5:238:18 | [VariableDeclarator] foo = Foo3.foo | tst.ts:238:5:238:7 | [VarDecl] foo | semmle.order | 1 | -| tst.ts:238:5:238:18 | [VariableDeclarator] foo = Foo3.foo | tst.ts:238:11:238:18 | [DotExpr] Foo3.foo | semmle.label | 2 | -| tst.ts:238:5:238:18 | [VariableDeclarator] foo = Foo3.foo | tst.ts:238:11:238:18 | [DotExpr] Foo3.foo | semmle.order | 2 | -| tst.ts:238:11:238:18 | [DotExpr] Foo3.foo | tst.ts:238:11:238:14 | [VarRef] Foo3 | semmle.label | 1 | -| tst.ts:238:11:238:18 | [DotExpr] Foo3.foo | tst.ts:238:11:238:14 | [VarRef] Foo3 | semmle.order | 1 | -| tst.ts:238:11:238:18 | [DotExpr] Foo3.foo | tst.ts:238:16:238:18 | [Label] foo | semmle.label | 2 | -| tst.ts:238:11:238:18 | [DotExpr] Foo3.foo | tst.ts:238:16:238:18 | [Label] foo | semmle.order | 2 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:240:8:240:11 | [VarDecl] TS46 | semmle.label | 1 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:240:8:240:11 | [VarDecl] TS46 | semmle.order | 1 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:241:3:241:15 | [ClassDefinition,TypeDefinition] class Base {} | semmle.label | 2 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:241:3:241:15 | [ClassDefinition,TypeDefinition] class Base {} | semmle.order | 2 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | semmle.label | 3 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | semmle.order | 3 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:252:3:254:50 | [TypeAliasDeclaration,TypeDefinition] type Ac ... ring }; | semmle.label | 4 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:252:3:254:50 | [TypeAliasDeclaration,TypeDefinition] type Ac ... ring }; | semmle.order | 4 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:256:3:263:3 | [FunctionDeclStmt] functio ... } } | semmle.label | 5 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:256:3:263:3 | [FunctionDeclStmt] functio ... } } | semmle.order | 5 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | semmle.label | 6 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | semmle.order | 6 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:271:3:276:7 | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | semmle.label | 7 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:271:3:276:7 | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | semmle.order | 7 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | semmle.label | 8 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | semmle.order | 8 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:282:3:287:5 | [ExprStmt] process ... , }); | semmle.label | 9 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:282:3:287:5 | [ExprStmt] process ... , }); | semmle.order | 9 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:289:3:289:63 | [TypeAliasDeclaration,TypeDefinition] type Fu ... > void; | semmle.label | 10 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:289:3:289:63 | [TypeAliasDeclaration,TypeDefinition] type Fu ... > void; | semmle.order | 10 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:291:3:295:4 | [DeclStmt] const f1 = ... | semmle.label | 11 | -| tst.ts:240:1:296:1 | [NamespaceDeclaration] module ... }; } | tst.ts:291:3:295:4 | [DeclStmt] const f1 = ... | semmle.order | 11 | -| tst.ts:241:3:241:15 | [ClassDefinition,TypeDefinition] class Base {} | tst.ts:241:9:241:12 | [VarDecl] Base | semmle.label | 1 | -| tst.ts:241:3:241:15 | [ClassDefinition,TypeDefinition] class Base {} | tst.ts:241:9:241:12 | [VarDecl] Base | semmle.order | 1 | -| tst.ts:241:3:241:15 | [ClassDefinition,TypeDefinition] class Base {} | tst.ts:241:14:241:13 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | 2 | -| tst.ts:241:3:241:15 | [ClassDefinition,TypeDefinition] class Base {} | tst.ts:241:14:241:13 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.order | 2 | -| tst.ts:241:14:241:13 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:241:14:241:13 | [FunctionExpr] () {} | semmle.label | 2 | -| tst.ts:241:14:241:13 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:241:14:241:13 | [FunctionExpr] () {} | semmle.order | 2 | -| tst.ts:241:14:241:13 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:241:14:241:13 | [Label] constructor | semmle.label | 1 | -| tst.ts:241:14:241:13 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:241:14:241:13 | [Label] constructor | semmle.order | 1 | -| tst.ts:241:14:241:13 | [FunctionExpr] () {} | tst.ts:241:14:241:13 | [BlockStmt] {} | semmle.label | 5 | -| tst.ts:241:14:241:13 | [FunctionExpr] () {} | tst.ts:241:14:241:13 | [BlockStmt] {} | semmle.order | 5 | -| tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | tst.ts:243:9:243:15 | [VarDecl] Derived | semmle.label | 1 | -| tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | tst.ts:243:9:243:15 | [VarDecl] Derived | semmle.order | 1 | -| tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | tst.ts:243:25:243:28 | [VarRef] Base | semmle.label | 2 | -| tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | tst.ts:243:25:243:28 | [VarRef] Base | semmle.order | 2 | -| tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | tst.ts:244:5:244:18 | [FieldDeclaration] myProp = true; | semmle.label | 3 | -| tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | tst.ts:244:5:244:18 | [FieldDeclaration] myProp = true; | semmle.order | 3 | -| tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | tst.ts:246:5:249:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | semmle.label | 4 | -| tst.ts:243:3:250:3 | [ClassDefinition,TypeDefinition] class D ... } } | tst.ts:246:5:249:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | semmle.order | 4 | -| tst.ts:244:5:244:18 | [FieldDeclaration] myProp = true; | tst.ts:244:5:244:10 | [Label] myProp | semmle.label | 1 | -| tst.ts:244:5:244:18 | [FieldDeclaration] myProp = true; | tst.ts:244:5:244:10 | [Label] myProp | semmle.order | 1 | -| tst.ts:244:5:244:18 | [FieldDeclaration] myProp = true; | tst.ts:244:14:244:17 | [Literal] true | semmle.label | 2 | -| tst.ts:244:5:244:18 | [FieldDeclaration] myProp = true; | tst.ts:244:14:244:17 | [Literal] true | semmle.order | 2 | -| tst.ts:246:5:249:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:246:5:249:5 | [FunctionExpr] constru ... ; } | semmle.label | 2 | -| tst.ts:246:5:249:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:246:5:249:5 | [FunctionExpr] constru ... ; } | semmle.order | 2 | -| tst.ts:246:5:249:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:246:5:249:5 | [Label] constructor | semmle.label | 1 | -| tst.ts:246:5:249:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:246:5:249:5 | [Label] constructor | semmle.order | 1 | -| tst.ts:246:5:249:5 | [FunctionExpr] constru ... ; } | tst.ts:246:19:249:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:246:5:249:5 | [FunctionExpr] constru ... ; } | tst.ts:246:19:249:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:246:19:249:5 | [BlockStmt] { ... ; } | tst.ts:247:7:247:52 | [ExprStmt] console ... er()"); | semmle.label | 1 | -| tst.ts:246:19:249:5 | [BlockStmt] { ... ; } | tst.ts:247:7:247:52 | [ExprStmt] console ... er()"); | semmle.order | 1 | -| tst.ts:246:19:249:5 | [BlockStmt] { ... ; } | tst.ts:248:7:248:14 | [ExprStmt] super(); | semmle.label | 2 | -| tst.ts:246:19:249:5 | [BlockStmt] { ... ; } | tst.ts:248:7:248:14 | [ExprStmt] super(); | semmle.order | 2 | -| tst.ts:247:7:247:17 | [DotExpr] console.log | tst.ts:247:7:247:13 | [VarRef] console | semmle.label | 1 | -| tst.ts:247:7:247:17 | [DotExpr] console.log | tst.ts:247:7:247:13 | [VarRef] console | semmle.order | 1 | -| tst.ts:247:7:247:17 | [DotExpr] console.log | tst.ts:247:15:247:17 | [Label] log | semmle.label | 2 | -| tst.ts:247:7:247:17 | [DotExpr] console.log | tst.ts:247:15:247:17 | [Label] log | semmle.order | 2 | -| tst.ts:247:7:247:51 | [MethodCallExpr] console ... per()") | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:247:7:247:51 | [MethodCallExpr] console ... per()") | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:247:7:247:51 | [MethodCallExpr] console ... per()") | tst.ts:247:7:247:17 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:247:7:247:51 | [MethodCallExpr] console ... per()") | tst.ts:247:7:247:17 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:247:7:247:52 | [ExprStmt] console ... er()"); | tst.ts:247:7:247:51 | [MethodCallExpr] console ... per()") | semmle.label | 1 | -| tst.ts:247:7:247:52 | [ExprStmt] console ... er()"); | tst.ts:247:7:247:51 | [MethodCallExpr] console ... per()") | semmle.order | 1 | -| tst.ts:248:7:248:13 | [CallExpr] super() | tst.ts:248:7:248:11 | [SuperExpr] super | semmle.label | 0 | -| tst.ts:248:7:248:13 | [CallExpr] super() | tst.ts:248:7:248:11 | [SuperExpr] super | semmle.order | 0 | -| tst.ts:248:7:248:14 | [ExprStmt] super(); | tst.ts:248:7:248:13 | [CallExpr] super() | semmle.label | 1 | -| tst.ts:248:7:248:14 | [ExprStmt] super(); | tst.ts:248:7:248:13 | [CallExpr] super() | semmle.order | 1 | -| tst.ts:252:3:254:50 | [TypeAliasDeclaration,TypeDefinition] type Ac ... ring }; | tst.ts:252:8:252:13 | [Identifier] Action | semmle.label | 1 | -| tst.ts:252:3:254:50 | [TypeAliasDeclaration,TypeDefinition] type Ac ... ring }; | tst.ts:252:8:252:13 | [Identifier] Action | semmle.order | 1 | -| tst.ts:252:3:254:50 | [TypeAliasDeclaration,TypeDefinition] type Ac ... ring }; | tst.ts:253:5:254:49 | [UnionTypeExpr] \| { kin ... tring } | semmle.label | 2 | -| tst.ts:252:3:254:50 | [TypeAliasDeclaration,TypeDefinition] type Ac ... ring }; | tst.ts:253:5:254:49 | [UnionTypeExpr] \| { kin ... tring } | semmle.order | 2 | -| tst.ts:253:5:254:49 | [UnionTypeExpr] \| { kin ... tring } | tst.ts:253:7:253:49 | [InterfaceTypeExpr] { kind: ... umber } | semmle.label | 1 | -| tst.ts:253:5:254:49 | [UnionTypeExpr] \| { kin ... tring } | tst.ts:253:7:253:49 | [InterfaceTypeExpr] { kind: ... umber } | semmle.order | 1 | -| tst.ts:253:5:254:49 | [UnionTypeExpr] \| { kin ... tring } | tst.ts:254:7:254:49 | [InterfaceTypeExpr] { kind: ... tring } | semmle.label | 2 | -| tst.ts:253:5:254:49 | [UnionTypeExpr] \| { kin ... tring } | tst.ts:254:7:254:49 | [InterfaceTypeExpr] { kind: ... tring } | semmle.order | 2 | -| tst.ts:253:7:253:49 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:253:9:253:31 | [FieldDeclaration] kind: " ... tents"; | semmle.label | 1 | -| tst.ts:253:7:253:49 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:253:9:253:31 | [FieldDeclaration] kind: " ... tents"; | semmle.order | 1 | -| tst.ts:253:7:253:49 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:253:33:253:47 | [FieldDeclaration] payload: number | semmle.label | 2 | -| tst.ts:253:7:253:49 | [InterfaceTypeExpr] { kind: ... umber } | tst.ts:253:33:253:47 | [FieldDeclaration] payload: number | semmle.order | 2 | -| tst.ts:253:9:253:31 | [FieldDeclaration] kind: " ... tents"; | tst.ts:253:9:253:12 | [Label] kind | semmle.label | 1 | -| tst.ts:253:9:253:31 | [FieldDeclaration] kind: " ... tents"; | tst.ts:253:9:253:12 | [Label] kind | semmle.order | 1 | -| tst.ts:253:9:253:31 | [FieldDeclaration] kind: " ... tents"; | tst.ts:253:15:253:30 | [LiteralTypeExpr] "NumberContents" | semmle.label | 2 | -| tst.ts:253:9:253:31 | [FieldDeclaration] kind: " ... tents"; | tst.ts:253:15:253:30 | [LiteralTypeExpr] "NumberContents" | semmle.order | 2 | -| tst.ts:253:33:253:47 | [FieldDeclaration] payload: number | tst.ts:253:33:253:39 | [Label] payload | semmle.label | 1 | -| tst.ts:253:33:253:47 | [FieldDeclaration] payload: number | tst.ts:253:33:253:39 | [Label] payload | semmle.order | 1 | -| tst.ts:253:33:253:47 | [FieldDeclaration] payload: number | tst.ts:253:42:253:47 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:253:33:253:47 | [FieldDeclaration] payload: number | tst.ts:253:42:253:47 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:254:7:254:49 | [InterfaceTypeExpr] { kind: ... tring } | tst.ts:254:9:254:31 | [FieldDeclaration] kind: " ... tents"; | semmle.label | 1 | -| tst.ts:254:7:254:49 | [InterfaceTypeExpr] { kind: ... tring } | tst.ts:254:9:254:31 | [FieldDeclaration] kind: " ... tents"; | semmle.order | 1 | -| tst.ts:254:7:254:49 | [InterfaceTypeExpr] { kind: ... tring } | tst.ts:254:33:254:47 | [FieldDeclaration] payload: string | semmle.label | 2 | -| tst.ts:254:7:254:49 | [InterfaceTypeExpr] { kind: ... tring } | tst.ts:254:33:254:47 | [FieldDeclaration] payload: string | semmle.order | 2 | -| tst.ts:254:9:254:31 | [FieldDeclaration] kind: " ... tents"; | tst.ts:254:9:254:12 | [Label] kind | semmle.label | 1 | -| tst.ts:254:9:254:31 | [FieldDeclaration] kind: " ... tents"; | tst.ts:254:9:254:12 | [Label] kind | semmle.order | 1 | -| tst.ts:254:9:254:31 | [FieldDeclaration] kind: " ... tents"; | tst.ts:254:15:254:30 | [LiteralTypeExpr] "StringContents" | semmle.label | 2 | -| tst.ts:254:9:254:31 | [FieldDeclaration] kind: " ... tents"; | tst.ts:254:15:254:30 | [LiteralTypeExpr] "StringContents" | semmle.order | 2 | -| tst.ts:254:33:254:47 | [FieldDeclaration] payload: string | tst.ts:254:33:254:39 | [Label] payload | semmle.label | 1 | -| tst.ts:254:33:254:47 | [FieldDeclaration] payload: string | tst.ts:254:33:254:39 | [Label] payload | semmle.order | 1 | -| tst.ts:254:33:254:47 | [FieldDeclaration] payload: string | tst.ts:254:42:254:47 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:254:33:254:47 | [FieldDeclaration] payload: string | tst.ts:254:42:254:47 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:256:3:263:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:256:3:263:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:256:3:263:3 | [FunctionDeclStmt] functio ... } } | tst.ts:256:12:256:24 | [VarDecl] processAction | semmle.label | 0 | -| tst.ts:256:3:263:3 | [FunctionDeclStmt] functio ... } } | tst.ts:256:12:256:24 | [VarDecl] processAction | semmle.order | 0 | -| tst.ts:256:3:263:3 | [FunctionDeclStmt] functio ... } } | tst.ts:256:42:263:3 | [BlockStmt] { c ... } } | semmle.label | 5 | -| tst.ts:256:3:263:3 | [FunctionDeclStmt] functio ... } } | tst.ts:256:42:263:3 | [BlockStmt] { c ... } } | semmle.order | 5 | -| tst.ts:256:26:256:31 | [SimpleParameter] action | tst.ts:256:34:256:39 | [LocalTypeAccess] Action | semmle.label | -2 | -| tst.ts:256:26:256:31 | [SimpleParameter] action | tst.ts:256:34:256:39 | [LocalTypeAccess] Action | semmle.order | -2 | -| tst.ts:256:42:263:3 | [BlockStmt] { c ... } } | tst.ts:257:5:257:37 | [DeclStmt] const { ... action; | semmle.label | 1 | -| tst.ts:256:42:263:3 | [BlockStmt] { c ... } } | tst.ts:257:5:257:37 | [DeclStmt] const { ... action; | semmle.order | 1 | -| tst.ts:256:42:263:3 | [BlockStmt] { c ... } } | tst.ts:258:5:262:5 | [IfStmt] if (kin ... g } | semmle.label | 2 | -| tst.ts:256:42:263:3 | [BlockStmt] { c ... } } | tst.ts:258:5:262:5 | [IfStmt] if (kin ... g } | semmle.order | 2 | -| tst.ts:257:5:257:37 | [DeclStmt] const { ... action; | tst.ts:257:11:257:36 | [VariableDeclarator] { kind, ... action | semmle.label | 1 | -| tst.ts:257:5:257:37 | [DeclStmt] const { ... action; | tst.ts:257:11:257:36 | [VariableDeclarator] { kind, ... action | semmle.order | 1 | -| tst.ts:257:11:257:27 | [ObjectPattern] { kind, payload } | tst.ts:257:13:257:16 | [PropertyPattern] kind | semmle.label | 1 | -| tst.ts:257:11:257:27 | [ObjectPattern] { kind, payload } | tst.ts:257:13:257:16 | [PropertyPattern] kind | semmle.order | 1 | -| tst.ts:257:11:257:27 | [ObjectPattern] { kind, payload } | tst.ts:257:19:257:25 | [PropertyPattern] payload | semmle.label | 2 | -| tst.ts:257:11:257:27 | [ObjectPattern] { kind, payload } | tst.ts:257:19:257:25 | [PropertyPattern] payload | semmle.order | 2 | -| tst.ts:257:11:257:36 | [VariableDeclarator] { kind, ... action | tst.ts:257:11:257:27 | [ObjectPattern] { kind, payload } | semmle.label | 1 | -| tst.ts:257:11:257:36 | [VariableDeclarator] { kind, ... action | tst.ts:257:11:257:27 | [ObjectPattern] { kind, payload } | semmle.order | 1 | -| tst.ts:257:11:257:36 | [VariableDeclarator] { kind, ... action | tst.ts:257:31:257:36 | [VarRef] action | semmle.label | 2 | -| tst.ts:257:11:257:36 | [VariableDeclarator] { kind, ... action | tst.ts:257:31:257:36 | [VarRef] action | semmle.order | 2 | -| tst.ts:257:13:257:16 | [PropertyPattern] kind | tst.ts:257:13:257:16 | [Label] kind | semmle.label | 1 | -| tst.ts:257:13:257:16 | [PropertyPattern] kind | tst.ts:257:13:257:16 | [Label] kind | semmle.order | 1 | -| tst.ts:257:13:257:16 | [PropertyPattern] kind | tst.ts:257:13:257:16 | [VarDecl] kind | semmle.label | 2 | -| tst.ts:257:13:257:16 | [PropertyPattern] kind | tst.ts:257:13:257:16 | [VarDecl] kind | semmle.order | 2 | -| tst.ts:257:19:257:25 | [PropertyPattern] payload | tst.ts:257:19:257:25 | [Label] payload | semmle.label | 1 | -| tst.ts:257:19:257:25 | [PropertyPattern] payload | tst.ts:257:19:257:25 | [Label] payload | semmle.order | 1 | -| tst.ts:257:19:257:25 | [PropertyPattern] payload | tst.ts:257:19:257:25 | [VarDecl] payload | semmle.label | 2 | -| tst.ts:257:19:257:25 | [PropertyPattern] payload | tst.ts:257:19:257:25 | [VarDecl] payload | semmle.order | 2 | -| tst.ts:258:5:262:5 | [IfStmt] if (kin ... g } | tst.ts:258:9:258:33 | [BinaryExpr] kind == ... ntents" | semmle.label | 1 | -| tst.ts:258:5:262:5 | [IfStmt] if (kin ... g } | tst.ts:258:9:258:33 | [BinaryExpr] kind == ... ntents" | semmle.order | 1 | -| tst.ts:258:5:262:5 | [IfStmt] if (kin ... g } | tst.ts:258:36:260:5 | [BlockStmt] { ... r } | semmle.label | 2 | -| tst.ts:258:5:262:5 | [IfStmt] if (kin ... g } | tst.ts:258:36:260:5 | [BlockStmt] { ... r } | semmle.order | 2 | -| tst.ts:258:5:262:5 | [IfStmt] if (kin ... g } | tst.ts:260:12:262:5 | [IfStmt] if (kin ... g } | semmle.label | 3 | -| tst.ts:258:5:262:5 | [IfStmt] if (kin ... g } | tst.ts:260:12:262:5 | [IfStmt] if (kin ... g } | semmle.order | 3 | -| tst.ts:258:9:258:33 | [BinaryExpr] kind == ... ntents" | tst.ts:258:9:258:12 | [VarRef] kind | semmle.label | 1 | -| tst.ts:258:9:258:33 | [BinaryExpr] kind == ... ntents" | tst.ts:258:9:258:12 | [VarRef] kind | semmle.order | 1 | -| tst.ts:258:9:258:33 | [BinaryExpr] kind == ... ntents" | tst.ts:258:18:258:33 | [Literal] "NumberContents" | semmle.label | 2 | -| tst.ts:258:9:258:33 | [BinaryExpr] kind == ... ntents" | tst.ts:258:18:258:33 | [Literal] "NumberContents" | semmle.order | 2 | -| tst.ts:258:36:260:5 | [BlockStmt] { ... r } | tst.ts:259:7:259:37 | [ExprStmt] console ... xed()); | semmle.label | 1 | -| tst.ts:258:36:260:5 | [BlockStmt] { ... r } | tst.ts:259:7:259:37 | [ExprStmt] console ... xed()); | semmle.order | 1 | -| tst.ts:259:7:259:17 | [DotExpr] console.log | tst.ts:259:7:259:13 | [VarRef] console | semmle.label | 1 | -| tst.ts:259:7:259:17 | [DotExpr] console.log | tst.ts:259:7:259:13 | [VarRef] console | semmle.order | 1 | -| tst.ts:259:7:259:17 | [DotExpr] console.log | tst.ts:259:15:259:17 | [Label] log | semmle.label | 2 | -| tst.ts:259:7:259:17 | [DotExpr] console.log | tst.ts:259:15:259:17 | [Label] log | semmle.order | 2 | -| tst.ts:259:7:259:36 | [MethodCallExpr] console ... ixed()) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:259:7:259:36 | [MethodCallExpr] console ... ixed()) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:259:7:259:36 | [MethodCallExpr] console ... ixed()) | tst.ts:259:7:259:17 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:259:7:259:36 | [MethodCallExpr] console ... ixed()) | tst.ts:259:7:259:17 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:259:7:259:37 | [ExprStmt] console ... xed()); | tst.ts:259:7:259:36 | [MethodCallExpr] console ... ixed()) | semmle.label | 1 | -| tst.ts:259:7:259:37 | [ExprStmt] console ... xed()); | tst.ts:259:7:259:36 | [MethodCallExpr] console ... ixed()) | semmle.order | 1 | -| tst.ts:259:19:259:33 | [DotExpr] payload.toFixed | tst.ts:259:19:259:25 | [VarRef] payload | semmle.label | 1 | -| tst.ts:259:19:259:33 | [DotExpr] payload.toFixed | tst.ts:259:19:259:25 | [VarRef] payload | semmle.order | 1 | -| tst.ts:259:19:259:33 | [DotExpr] payload.toFixed | tst.ts:259:27:259:33 | [Label] toFixed | semmle.label | 2 | -| tst.ts:259:19:259:33 | [DotExpr] payload.toFixed | tst.ts:259:27:259:33 | [Label] toFixed | semmle.order | 2 | -| tst.ts:259:19:259:35 | [MethodCallExpr] payload.toFixed() | tst.ts:259:19:259:33 | [DotExpr] payload.toFixed | semmle.label | 0 | -| tst.ts:259:19:259:35 | [MethodCallExpr] payload.toFixed() | tst.ts:259:19:259:33 | [DotExpr] payload.toFixed | semmle.order | 0 | -| tst.ts:260:12:262:5 | [IfStmt] if (kin ... g } | tst.ts:260:16:260:40 | [BinaryExpr] kind == ... ntents" | semmle.label | 1 | -| tst.ts:260:12:262:5 | [IfStmt] if (kin ... g } | tst.ts:260:16:260:40 | [BinaryExpr] kind == ... ntents" | semmle.order | 1 | -| tst.ts:260:12:262:5 | [IfStmt] if (kin ... g } | tst.ts:260:43:262:5 | [BlockStmt] { ... g } | semmle.label | 2 | -| tst.ts:260:12:262:5 | [IfStmt] if (kin ... g } | tst.ts:260:43:262:5 | [BlockStmt] { ... g } | semmle.order | 2 | -| tst.ts:260:16:260:40 | [BinaryExpr] kind == ... ntents" | tst.ts:260:16:260:19 | [VarRef] kind | semmle.label | 1 | -| tst.ts:260:16:260:40 | [BinaryExpr] kind == ... ntents" | tst.ts:260:16:260:19 | [VarRef] kind | semmle.order | 1 | -| tst.ts:260:16:260:40 | [BinaryExpr] kind == ... ntents" | tst.ts:260:25:260:40 | [Literal] "StringContents" | semmle.label | 2 | -| tst.ts:260:16:260:40 | [BinaryExpr] kind == ... ntents" | tst.ts:260:25:260:40 | [Literal] "StringContents" | semmle.order | 2 | -| tst.ts:260:43:262:5 | [BlockStmt] { ... g } | tst.ts:261:7:261:41 | [ExprStmt] console ... ase()); | semmle.label | 1 | -| tst.ts:260:43:262:5 | [BlockStmt] { ... g } | tst.ts:261:7:261:41 | [ExprStmt] console ... ase()); | semmle.order | 1 | -| tst.ts:261:7:261:17 | [DotExpr] console.log | tst.ts:261:7:261:13 | [VarRef] console | semmle.label | 1 | -| tst.ts:261:7:261:17 | [DotExpr] console.log | tst.ts:261:7:261:13 | [VarRef] console | semmle.order | 1 | -| tst.ts:261:7:261:17 | [DotExpr] console.log | tst.ts:261:15:261:17 | [Label] log | semmle.label | 2 | -| tst.ts:261:7:261:17 | [DotExpr] console.log | tst.ts:261:15:261:17 | [Label] log | semmle.order | 2 | -| tst.ts:261:7:261:40 | [MethodCallExpr] console ... Case()) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:261:7:261:40 | [MethodCallExpr] console ... Case()) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:261:7:261:40 | [MethodCallExpr] console ... Case()) | tst.ts:261:7:261:17 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:261:7:261:40 | [MethodCallExpr] console ... Case()) | tst.ts:261:7:261:17 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:261:7:261:41 | [ExprStmt] console ... ase()); | tst.ts:261:7:261:40 | [MethodCallExpr] console ... Case()) | semmle.label | 1 | -| tst.ts:261:7:261:41 | [ExprStmt] console ... ase()); | tst.ts:261:7:261:40 | [MethodCallExpr] console ... Case()) | semmle.order | 1 | -| tst.ts:261:19:261:37 | [DotExpr] payload.toLowerCase | tst.ts:261:19:261:25 | [VarRef] payload | semmle.label | 1 | -| tst.ts:261:19:261:37 | [DotExpr] payload.toLowerCase | tst.ts:261:19:261:25 | [VarRef] payload | semmle.order | 1 | -| tst.ts:261:19:261:37 | [DotExpr] payload.toLowerCase | tst.ts:261:27:261:37 | [Label] toLowerCase | semmle.label | 2 | -| tst.ts:261:19:261:37 | [DotExpr] payload.toLowerCase | tst.ts:261:27:261:37 | [Label] toLowerCase | semmle.order | 2 | -| tst.ts:261:19:261:39 | [MethodCallExpr] payload ... rCase() | tst.ts:261:19:261:37 | [DotExpr] payload.toLowerCase | semmle.label | 0 | -| tst.ts:261:19:261:39 | [MethodCallExpr] payload ... rCase() | tst.ts:261:19:261:37 | [DotExpr] payload.toLowerCase | semmle.order | 0 | -| tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | tst.ts:265:13:265:19 | [Identifier] TypeMap | semmle.label | 1 | -| tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | tst.ts:265:13:265:19 | [Identifier] TypeMap | semmle.order | 1 | -| tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | tst.ts:266:5:266:19 | [FieldDeclaration] number: number; | semmle.label | 2 | -| tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | tst.ts:266:5:266:19 | [FieldDeclaration] number: number; | semmle.order | 2 | -| tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | tst.ts:267:5:267:19 | [FieldDeclaration] string: string; | semmle.label | 3 | -| tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | tst.ts:267:5:267:19 | [FieldDeclaration] string: string; | semmle.order | 3 | -| tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | tst.ts:268:5:268:21 | [FieldDeclaration] boolean: boolean; | semmle.label | 4 | -| tst.ts:265:3:269:3 | [InterfaceDeclaration,TypeDefinition] interfa ... an; } | tst.ts:268:5:268:21 | [FieldDeclaration] boolean: boolean; | semmle.order | 4 | -| tst.ts:266:5:266:19 | [FieldDeclaration] number: number; | tst.ts:266:5:266:10 | [Label] number | semmle.label | 1 | -| tst.ts:266:5:266:19 | [FieldDeclaration] number: number; | tst.ts:266:5:266:10 | [Label] number | semmle.order | 1 | -| tst.ts:266:5:266:19 | [FieldDeclaration] number: number; | tst.ts:266:13:266:18 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:266:5:266:19 | [FieldDeclaration] number: number; | tst.ts:266:13:266:18 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:267:5:267:19 | [FieldDeclaration] string: string; | tst.ts:267:5:267:10 | [Label] string | semmle.label | 1 | -| tst.ts:267:5:267:19 | [FieldDeclaration] string: string; | tst.ts:267:5:267:10 | [Label] string | semmle.order | 1 | -| tst.ts:267:5:267:19 | [FieldDeclaration] string: string; | tst.ts:267:13:267:18 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:267:5:267:19 | [FieldDeclaration] string: string; | tst.ts:267:13:267:18 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:268:5:268:21 | [FieldDeclaration] boolean: boolean; | tst.ts:268:5:268:11 | [Label] boolean | semmle.label | 1 | -| tst.ts:268:5:268:21 | [FieldDeclaration] boolean: boolean; | tst.ts:268:5:268:11 | [Label] boolean | semmle.order | 1 | -| tst.ts:268:5:268:21 | [FieldDeclaration] boolean: boolean; | tst.ts:268:14:268:20 | [KeywordTypeExpr] boolean | semmle.label | 2 | -| tst.ts:268:5:268:21 | [FieldDeclaration] boolean: boolean; | tst.ts:268:14:268:20 | [KeywordTypeExpr] boolean | semmle.order | 2 | -| tst.ts:271:3:276:7 | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| tst.ts:271:3:276:7 | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| tst.ts:271:3:276:7 | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | tst.ts:271:8:271:18 | [Identifier] UnionRecord | semmle.label | 1 | -| tst.ts:271:3:276:7 | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | tst.ts:271:8:271:18 | [Identifier] UnionRecord | semmle.order | 1 | -| tst.ts:271:3:276:7 | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | tst.ts:271:47:276:6 | [IndexedAccessTypeExpr] { [ ... }[P] | semmle.label | 3 | -| tst.ts:271:3:276:7 | [TypeAliasDeclaration,TypeDefinition] type Un ... }[P]; | tst.ts:271:47:276:6 | [IndexedAccessTypeExpr] { [ ... }[P] | semmle.order | 3 | -| tst.ts:271:20:271:42 | [TypeParameter] P exten ... TypeMap | tst.ts:271:20:271:20 | [Identifier] P | semmle.label | 1 | -| tst.ts:271:20:271:42 | [TypeParameter] P exten ... TypeMap | tst.ts:271:20:271:20 | [Identifier] P | semmle.order | 1 | -| tst.ts:271:20:271:42 | [TypeParameter] P exten ... TypeMap | tst.ts:271:30:271:42 | [KeyofTypeExpr] keyof TypeMap | semmle.label | 2 | -| tst.ts:271:20:271:42 | [TypeParameter] P exten ... TypeMap | tst.ts:271:30:271:42 | [KeyofTypeExpr] keyof TypeMap | semmle.order | 2 | -| tst.ts:271:30:271:42 | [KeyofTypeExpr] keyof TypeMap | tst.ts:271:36:271:42 | [LocalTypeAccess] TypeMap | semmle.label | 1 | -| tst.ts:271:30:271:42 | [KeyofTypeExpr] keyof TypeMap | tst.ts:271:36:271:42 | [LocalTypeAccess] TypeMap | semmle.order | 1 | -| tst.ts:271:47:276:3 | [MappedTypeExpr] { [ ... }; } | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| tst.ts:271:47:276:3 | [MappedTypeExpr] { [ ... }; } | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| tst.ts:271:47:276:3 | [MappedTypeExpr] { [ ... }; } | tst.ts:272:15:275:5 | [InterfaceTypeExpr] { ... ; } | semmle.label | 2 | -| tst.ts:271:47:276:3 | [MappedTypeExpr] { [ ... }; } | tst.ts:272:15:275:5 | [InterfaceTypeExpr] { ... ; } | semmle.order | 2 | -| tst.ts:271:47:276:6 | [IndexedAccessTypeExpr] { [ ... }[P] | tst.ts:271:47:276:3 | [MappedTypeExpr] { [ ... }; } | semmle.label | 1 | -| tst.ts:271:47:276:6 | [IndexedAccessTypeExpr] { [ ... }[P] | tst.ts:271:47:276:3 | [MappedTypeExpr] { [ ... }; } | semmle.order | 1 | -| tst.ts:271:47:276:6 | [IndexedAccessTypeExpr] { [ ... }[P] | tst.ts:276:5:276:5 | [LocalTypeAccess] P | semmle.label | 2 | -| tst.ts:271:47:276:6 | [IndexedAccessTypeExpr] { [ ... }[P] | tst.ts:276:5:276:5 | [LocalTypeAccess] P | semmle.order | 2 | -| tst.ts:272:6:272:11 | [TypeParameter] K in P | tst.ts:272:6:272:6 | [Identifier] K | semmle.label | 1 | -| tst.ts:272:6:272:11 | [TypeParameter] K in P | tst.ts:272:6:272:6 | [Identifier] K | semmle.order | 1 | -| tst.ts:272:6:272:11 | [TypeParameter] K in P | tst.ts:272:11:272:11 | [LocalTypeAccess] P | semmle.label | 2 | -| tst.ts:272:6:272:11 | [TypeParameter] K in P | tst.ts:272:11:272:11 | [LocalTypeAccess] P | semmle.order | 2 | -| tst.ts:272:15:275:5 | [InterfaceTypeExpr] { ... ; } | tst.ts:273:7:273:14 | [FieldDeclaration] kind: K; | semmle.label | 1 | -| tst.ts:272:15:275:5 | [InterfaceTypeExpr] { ... ; } | tst.ts:273:7:273:14 | [FieldDeclaration] kind: K; | semmle.order | 1 | -| tst.ts:272:15:275:5 | [InterfaceTypeExpr] { ... ; } | tst.ts:274:7:274:33 | [FieldDeclaration] f: (p: ... > void; | semmle.label | 2 | -| tst.ts:272:15:275:5 | [InterfaceTypeExpr] { ... ; } | tst.ts:274:7:274:33 | [FieldDeclaration] f: (p: ... > void; | semmle.order | 2 | -| tst.ts:273:7:273:14 | [FieldDeclaration] kind: K; | tst.ts:273:7:273:10 | [Label] kind | semmle.label | 1 | -| tst.ts:273:7:273:14 | [FieldDeclaration] kind: K; | tst.ts:273:7:273:10 | [Label] kind | semmle.order | 1 | -| tst.ts:273:7:273:14 | [FieldDeclaration] kind: K; | tst.ts:273:13:273:13 | [LocalTypeAccess] K | semmle.label | 2 | -| tst.ts:273:7:273:14 | [FieldDeclaration] kind: K; | tst.ts:273:13:273:13 | [LocalTypeAccess] K | semmle.order | 2 | -| tst.ts:274:7:274:33 | [FieldDeclaration] f: (p: ... > void; | tst.ts:274:7:274:7 | [Label] f | semmle.label | 1 | -| tst.ts:274:7:274:33 | [FieldDeclaration] f: (p: ... > void; | tst.ts:274:7:274:7 | [Label] f | semmle.order | 1 | -| tst.ts:274:7:274:33 | [FieldDeclaration] f: (p: ... > void; | tst.ts:274:10:274:32 | [FunctionTypeExpr] (p: Typ ... => void | semmle.label | 2 | -| tst.ts:274:7:274:33 | [FieldDeclaration] f: (p: ... > void; | tst.ts:274:10:274:32 | [FunctionTypeExpr] (p: Typ ... => void | semmle.order | 2 | -| tst.ts:274:10:274:32 | [FunctionExpr] (p: Typ ... => void | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:274:10:274:32 | [FunctionExpr] (p: Typ ... => void | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:274:10:274:32 | [FunctionExpr] (p: Typ ... => void | tst.ts:274:29:274:32 | [KeywordTypeExpr] void | semmle.label | 4 | -| tst.ts:274:10:274:32 | [FunctionExpr] (p: Typ ... => void | tst.ts:274:29:274:32 | [KeywordTypeExpr] void | semmle.order | 4 | -| tst.ts:274:10:274:32 | [FunctionTypeExpr] (p: Typ ... => void | tst.ts:274:10:274:32 | [FunctionExpr] (p: Typ ... => void | semmle.label | 1 | -| tst.ts:274:10:274:32 | [FunctionTypeExpr] (p: Typ ... => void | tst.ts:274:10:274:32 | [FunctionExpr] (p: Typ ... => void | semmle.order | 1 | -| tst.ts:274:11:274:11 | [SimpleParameter] p | tst.ts:274:14:274:23 | [IndexedAccessTypeExpr] TypeMap[K] | semmle.label | -2 | -| tst.ts:274:11:274:11 | [SimpleParameter] p | tst.ts:274:14:274:23 | [IndexedAccessTypeExpr] TypeMap[K] | semmle.order | -2 | -| tst.ts:274:14:274:23 | [IndexedAccessTypeExpr] TypeMap[K] | tst.ts:274:14:274:20 | [LocalTypeAccess] TypeMap | semmle.label | 1 | -| tst.ts:274:14:274:23 | [IndexedAccessTypeExpr] TypeMap[K] | tst.ts:274:14:274:20 | [LocalTypeAccess] TypeMap | semmle.order | 1 | -| tst.ts:274:14:274:23 | [IndexedAccessTypeExpr] TypeMap[K] | tst.ts:274:22:274:22 | [LocalTypeAccess] K | semmle.label | 2 | -| tst.ts:274:14:274:23 | [IndexedAccessTypeExpr] TypeMap[K] | tst.ts:274:22:274:22 | [LocalTypeAccess] K | semmle.order | 2 | -| tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | file://:0:0:0:0 | (TypeParameters) | semmle.label | 2 | -| tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | file://:0:0:0:0 | (TypeParameters) | semmle.order | 2 | -| tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | tst.ts:278:12:278:24 | [VarDecl] processRecord | semmle.label | 0 | -| tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | tst.ts:278:12:278:24 | [VarDecl] processRecord | semmle.order | 0 | -| tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | tst.ts:278:75:280:3 | [BlockStmt] { r ... v); } | semmle.label | 5 | -| tst.ts:278:3:280:3 | [FunctionDeclStmt] functio ... v); } | tst.ts:278:75:280:3 | [BlockStmt] { r ... v); } | semmle.order | 5 | -| tst.ts:278:26:278:48 | [TypeParameter] K exten ... TypeMap | tst.ts:278:26:278:26 | [Identifier] K | semmle.label | 1 | -| tst.ts:278:26:278:48 | [TypeParameter] K exten ... TypeMap | tst.ts:278:26:278:26 | [Identifier] K | semmle.order | 1 | -| tst.ts:278:26:278:48 | [TypeParameter] K exten ... TypeMap | tst.ts:278:36:278:48 | [KeyofTypeExpr] keyof TypeMap | semmle.label | 2 | -| tst.ts:278:26:278:48 | [TypeParameter] K exten ... TypeMap | tst.ts:278:36:278:48 | [KeyofTypeExpr] keyof TypeMap | semmle.order | 2 | -| tst.ts:278:36:278:48 | [KeyofTypeExpr] keyof TypeMap | tst.ts:278:42:278:48 | [LocalTypeAccess] TypeMap | semmle.label | 1 | -| tst.ts:278:36:278:48 | [KeyofTypeExpr] keyof TypeMap | tst.ts:278:42:278:48 | [LocalTypeAccess] TypeMap | semmle.order | 1 | -| tst.ts:278:51:278:56 | [SimpleParameter] record | tst.ts:278:59:278:72 | [GenericTypeExpr] UnionRecord | semmle.label | -2 | -| tst.ts:278:51:278:56 | [SimpleParameter] record | tst.ts:278:59:278:72 | [GenericTypeExpr] UnionRecord | semmle.order | -2 | -| tst.ts:278:59:278:72 | [GenericTypeExpr] UnionRecord | tst.ts:278:59:278:69 | [LocalTypeAccess] UnionRecord | semmle.label | 1 | -| tst.ts:278:59:278:72 | [GenericTypeExpr] UnionRecord | tst.ts:278:59:278:69 | [LocalTypeAccess] UnionRecord | semmle.order | 1 | -| tst.ts:278:59:278:72 | [GenericTypeExpr] UnionRecord | tst.ts:278:71:278:71 | [LocalTypeAccess] K | semmle.label | 2 | -| tst.ts:278:59:278:72 | [GenericTypeExpr] UnionRecord | tst.ts:278:71:278:71 | [LocalTypeAccess] K | semmle.order | 2 | -| tst.ts:278:75:280:3 | [BlockStmt] { r ... v); } | tst.ts:279:5:279:23 | [ExprStmt] record.f(record.v); | semmle.label | 1 | -| tst.ts:278:75:280:3 | [BlockStmt] { r ... v); } | tst.ts:279:5:279:23 | [ExprStmt] record.f(record.v); | semmle.order | 1 | -| tst.ts:279:5:279:12 | [DotExpr] record.f | tst.ts:279:5:279:10 | [VarRef] record | semmle.label | 1 | -| tst.ts:279:5:279:12 | [DotExpr] record.f | tst.ts:279:5:279:10 | [VarRef] record | semmle.order | 1 | -| tst.ts:279:5:279:12 | [DotExpr] record.f | tst.ts:279:12:279:12 | [Label] f | semmle.label | 2 | -| tst.ts:279:5:279:12 | [DotExpr] record.f | tst.ts:279:12:279:12 | [Label] f | semmle.order | 2 | -| tst.ts:279:5:279:22 | [MethodCallExpr] record.f(record.v) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:279:5:279:22 | [MethodCallExpr] record.f(record.v) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:279:5:279:22 | [MethodCallExpr] record.f(record.v) | tst.ts:279:5:279:12 | [DotExpr] record.f | semmle.label | 0 | -| tst.ts:279:5:279:22 | [MethodCallExpr] record.f(record.v) | tst.ts:279:5:279:12 | [DotExpr] record.f | semmle.order | 0 | -| tst.ts:279:5:279:23 | [ExprStmt] record.f(record.v); | tst.ts:279:5:279:22 | [MethodCallExpr] record.f(record.v) | semmle.label | 1 | -| tst.ts:279:5:279:23 | [ExprStmt] record.f(record.v); | tst.ts:279:5:279:22 | [MethodCallExpr] record.f(record.v) | semmle.order | 1 | -| tst.ts:279:14:279:21 | [DotExpr] record.v | tst.ts:279:14:279:19 | [VarRef] record | semmle.label | 1 | -| tst.ts:279:14:279:21 | [DotExpr] record.v | tst.ts:279:14:279:19 | [VarRef] record | semmle.order | 1 | -| tst.ts:279:14:279:21 | [DotExpr] record.v | tst.ts:279:21:279:21 | [Label] v | semmle.label | 2 | -| tst.ts:279:14:279:21 | [DotExpr] record.v | tst.ts:279:21:279:21 | [Label] v | semmle.order | 2 | -| tst.ts:282:3:287:4 | [CallExpr] process ... }, }) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:282:3:287:4 | [CallExpr] process ... }, }) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:282:3:287:4 | [CallExpr] process ... }, }) | tst.ts:282:3:282:15 | [VarRef] processRecord | semmle.label | 0 | -| tst.ts:282:3:287:4 | [CallExpr] process ... }, }) | tst.ts:282:3:282:15 | [VarRef] processRecord | semmle.order | 0 | -| tst.ts:282:3:287:5 | [ExprStmt] process ... , }); | tst.ts:282:3:287:4 | [CallExpr] process ... }, }) | semmle.label | 1 | -| tst.ts:282:3:287:5 | [ExprStmt] process ... , }); | tst.ts:282:3:287:4 | [CallExpr] process ... }, }) | semmle.order | 1 | -| tst.ts:282:17:287:3 | [ObjectExpr] {kind: ...} | tst.ts:283:5:283:18 | [Property] kind: "string" | semmle.label | 1 | -| tst.ts:282:17:287:3 | [ObjectExpr] {kind: ...} | tst.ts:283:5:283:18 | [Property] kind: "string" | semmle.order | 1 | -| tst.ts:282:17:287:3 | [ObjectExpr] {kind: ...} | tst.ts:284:5:286:5 | [Property] f: (val ... g } | semmle.label | 2 | -| tst.ts:282:17:287:3 | [ObjectExpr] {kind: ...} | tst.ts:284:5:286:5 | [Property] f: (val ... g } | semmle.order | 2 | -| tst.ts:283:5:283:18 | [Property] kind: "string" | tst.ts:283:5:283:8 | [Label] kind | semmle.label | 1 | -| tst.ts:283:5:283:18 | [Property] kind: "string" | tst.ts:283:5:283:8 | [Label] kind | semmle.order | 1 | -| tst.ts:283:5:283:18 | [Property] kind: "string" | tst.ts:283:11:283:18 | [Literal] "string" | semmle.label | 2 | -| tst.ts:283:5:283:18 | [Property] kind: "string" | tst.ts:283:11:283:18 | [Literal] "string" | semmle.order | 2 | -| tst.ts:284:5:286:5 | [Property] f: (val ... g } | tst.ts:284:5:284:5 | [Label] f | semmle.label | 1 | -| tst.ts:284:5:286:5 | [Property] f: (val ... g } | tst.ts:284:5:284:5 | [Label] f | semmle.order | 1 | -| tst.ts:284:5:286:5 | [Property] f: (val ... g } | tst.ts:284:8:286:5 | [ArrowFunctionExpr] (val) = ... g } | semmle.label | 2 | -| tst.ts:284:5:286:5 | [Property] f: (val ... g } | tst.ts:284:8:286:5 | [ArrowFunctionExpr] (val) = ... g } | semmle.order | 2 | -| tst.ts:284:8:286:5 | [ArrowFunctionExpr] (val) = ... g } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:284:8:286:5 | [ArrowFunctionExpr] (val) = ... g } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:284:8:286:5 | [ArrowFunctionExpr] (val) = ... g } | tst.ts:284:17:286:5 | [BlockStmt] { ... g } | semmle.label | 5 | -| tst.ts:284:8:286:5 | [ArrowFunctionExpr] (val) = ... g } | tst.ts:284:17:286:5 | [BlockStmt] { ... g } | semmle.order | 5 | -| tst.ts:284:17:286:5 | [BlockStmt] { ... g } | tst.ts:285:7:285:37 | [ExprStmt] console ... ase()); | semmle.label | 1 | -| tst.ts:284:17:286:5 | [BlockStmt] { ... g } | tst.ts:285:7:285:37 | [ExprStmt] console ... ase()); | semmle.order | 1 | -| tst.ts:285:7:285:17 | [DotExpr] console.log | tst.ts:285:7:285:13 | [VarRef] console | semmle.label | 1 | -| tst.ts:285:7:285:17 | [DotExpr] console.log | tst.ts:285:7:285:13 | [VarRef] console | semmle.order | 1 | -| tst.ts:285:7:285:17 | [DotExpr] console.log | tst.ts:285:15:285:17 | [Label] log | semmle.label | 2 | -| tst.ts:285:7:285:17 | [DotExpr] console.log | tst.ts:285:15:285:17 | [Label] log | semmle.order | 2 | -| tst.ts:285:7:285:36 | [MethodCallExpr] console ... Case()) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:285:7:285:36 | [MethodCallExpr] console ... Case()) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:285:7:285:36 | [MethodCallExpr] console ... Case()) | tst.ts:285:7:285:17 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:285:7:285:36 | [MethodCallExpr] console ... Case()) | tst.ts:285:7:285:17 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:285:7:285:37 | [ExprStmt] console ... ase()); | tst.ts:285:7:285:36 | [MethodCallExpr] console ... Case()) | semmle.label | 1 | -| tst.ts:285:7:285:37 | [ExprStmt] console ... ase()); | tst.ts:285:7:285:36 | [MethodCallExpr] console ... Case()) | semmle.order | 1 | -| tst.ts:285:19:285:33 | [DotExpr] val.toUpperCase | tst.ts:285:19:285:21 | [VarRef] val | semmle.label | 1 | -| tst.ts:285:19:285:33 | [DotExpr] val.toUpperCase | tst.ts:285:19:285:21 | [VarRef] val | semmle.order | 1 | -| tst.ts:285:19:285:33 | [DotExpr] val.toUpperCase | tst.ts:285:23:285:33 | [Label] toUpperCase | semmle.label | 2 | -| tst.ts:285:19:285:33 | [DotExpr] val.toUpperCase | tst.ts:285:23:285:33 | [Label] toUpperCase | semmle.order | 2 | -| tst.ts:285:19:285:35 | [MethodCallExpr] val.toUpperCase() | tst.ts:285:19:285:33 | [DotExpr] val.toUpperCase | semmle.label | 0 | -| tst.ts:285:19:285:35 | [MethodCallExpr] val.toUpperCase() | tst.ts:285:19:285:33 | [DotExpr] val.toUpperCase | semmle.order | 0 | -| tst.ts:289:3:289:63 | [TypeAliasDeclaration,TypeDefinition] type Fu ... > void; | tst.ts:289:8:289:11 | [Identifier] Func | semmle.label | 1 | -| tst.ts:289:3:289:63 | [TypeAliasDeclaration,TypeDefinition] type Fu ... > void; | tst.ts:289:8:289:11 | [Identifier] Func | semmle.order | 1 | -| tst.ts:289:3:289:63 | [TypeAliasDeclaration,TypeDefinition] type Fu ... > void; | tst.ts:289:15:289:62 | [FunctionTypeExpr] (...arg ... => void | semmle.label | 2 | -| tst.ts:289:3:289:63 | [TypeAliasDeclaration,TypeDefinition] type Fu ... > void; | tst.ts:289:15:289:62 | [FunctionTypeExpr] (...arg ... => void | semmle.order | 2 | -| tst.ts:289:15:289:62 | [FunctionExpr] (...arg ... => void | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:289:15:289:62 | [FunctionExpr] (...arg ... => void | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:289:15:289:62 | [FunctionExpr] (...arg ... => void | tst.ts:289:59:289:62 | [KeywordTypeExpr] void | semmle.label | 4 | -| tst.ts:289:15:289:62 | [FunctionExpr] (...arg ... => void | tst.ts:289:59:289:62 | [KeywordTypeExpr] void | semmle.order | 4 | -| tst.ts:289:15:289:62 | [FunctionTypeExpr] (...arg ... => void | tst.ts:289:15:289:62 | [FunctionExpr] (...arg ... => void | semmle.label | 1 | -| tst.ts:289:15:289:62 | [FunctionTypeExpr] (...arg ... => void | tst.ts:289:15:289:62 | [FunctionExpr] (...arg ... => void | semmle.order | 1 | -| tst.ts:289:19:289:22 | [SimpleParameter] args | tst.ts:289:25:289:53 | [UnionTypeExpr] ["a", n ... string] | semmle.label | -2 | -| tst.ts:289:19:289:22 | [SimpleParameter] args | tst.ts:289:25:289:53 | [UnionTypeExpr] ["a", n ... string] | semmle.order | -2 | -| tst.ts:289:25:289:37 | [TupleTypeExpr] ["a", number] | tst.ts:289:26:289:28 | [LiteralTypeExpr] "a" | semmle.label | 1 | -| tst.ts:289:25:289:37 | [TupleTypeExpr] ["a", number] | tst.ts:289:26:289:28 | [LiteralTypeExpr] "a" | semmle.order | 1 | -| tst.ts:289:25:289:37 | [TupleTypeExpr] ["a", number] | tst.ts:289:31:289:36 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:289:25:289:37 | [TupleTypeExpr] ["a", number] | tst.ts:289:31:289:36 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:289:25:289:53 | [UnionTypeExpr] ["a", n ... string] | tst.ts:289:25:289:37 | [TupleTypeExpr] ["a", number] | semmle.label | 1 | -| tst.ts:289:25:289:53 | [UnionTypeExpr] ["a", n ... string] | tst.ts:289:25:289:37 | [TupleTypeExpr] ["a", number] | semmle.order | 1 | -| tst.ts:289:25:289:53 | [UnionTypeExpr] ["a", n ... string] | tst.ts:289:41:289:53 | [TupleTypeExpr] ["b", string] | semmle.label | 2 | -| tst.ts:289:25:289:53 | [UnionTypeExpr] ["a", n ... string] | tst.ts:289:41:289:53 | [TupleTypeExpr] ["b", string] | semmle.order | 2 | -| tst.ts:289:41:289:53 | [TupleTypeExpr] ["b", string] | tst.ts:289:42:289:44 | [LiteralTypeExpr] "b" | semmle.label | 1 | -| tst.ts:289:41:289:53 | [TupleTypeExpr] ["b", string] | tst.ts:289:42:289:44 | [LiteralTypeExpr] "b" | semmle.order | 1 | -| tst.ts:289:41:289:53 | [TupleTypeExpr] ["b", string] | tst.ts:289:47:289:52 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:289:41:289:53 | [TupleTypeExpr] ["b", string] | tst.ts:289:47:289:52 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:291:3:295:4 | [DeclStmt] const f1 = ... | tst.ts:291:9:295:3 | [VariableDeclarator] f1: Fun ... } } | semmle.label | 1 | -| tst.ts:291:3:295:4 | [DeclStmt] const f1 = ... | tst.ts:291:9:295:3 | [VariableDeclarator] f1: Fun ... } } | semmle.order | 1 | -| tst.ts:291:9:295:3 | [VariableDeclarator] f1: Fun ... } } | tst.ts:291:9:291:10 | [VarDecl] f1 | semmle.label | 1 | -| tst.ts:291:9:295:3 | [VariableDeclarator] f1: Fun ... } } | tst.ts:291:9:291:10 | [VarDecl] f1 | semmle.order | 1 | -| tst.ts:291:9:295:3 | [VariableDeclarator] f1: Fun ... } } | tst.ts:291:13:291:16 | [LocalTypeAccess] Func | semmle.label | 2 | -| tst.ts:291:9:295:3 | [VariableDeclarator] f1: Fun ... } } | tst.ts:291:13:291:16 | [LocalTypeAccess] Func | semmle.order | 2 | -| tst.ts:291:9:295:3 | [VariableDeclarator] f1: Fun ... } } | tst.ts:291:20:295:3 | [ArrowFunctionExpr] (kind, ... } } | semmle.label | 3 | -| tst.ts:291:9:295:3 | [VariableDeclarator] f1: Fun ... } } | tst.ts:291:20:295:3 | [ArrowFunctionExpr] (kind, ... } } | semmle.order | 3 | -| tst.ts:291:20:295:3 | [ArrowFunctionExpr] (kind, ... } } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:291:20:295:3 | [ArrowFunctionExpr] (kind, ... } } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:291:20:295:3 | [ArrowFunctionExpr] (kind, ... } } | tst.ts:291:39:295:3 | [BlockStmt] { i ... } } | semmle.label | 5 | -| tst.ts:291:20:295:3 | [ArrowFunctionExpr] (kind, ... } } | tst.ts:291:39:295:3 | [BlockStmt] { i ... } } | semmle.order | 5 | -| tst.ts:291:39:295:3 | [BlockStmt] { i ... } } | tst.ts:292:5:294:5 | [IfStmt] if (kin ... r } | semmle.label | 1 | -| tst.ts:291:39:295:3 | [BlockStmt] { i ... } } | tst.ts:292:5:294:5 | [IfStmt] if (kin ... r } | semmle.order | 1 | -| tst.ts:292:5:294:5 | [IfStmt] if (kin ... r } | tst.ts:292:9:292:20 | [BinaryExpr] kind === "a" | semmle.label | 1 | -| tst.ts:292:5:294:5 | [IfStmt] if (kin ... r } | tst.ts:292:9:292:20 | [BinaryExpr] kind === "a" | semmle.order | 1 | -| tst.ts:292:5:294:5 | [IfStmt] if (kin ... r } | tst.ts:292:23:294:5 | [BlockStmt] { ... r } | semmle.label | 2 | -| tst.ts:292:5:294:5 | [IfStmt] if (kin ... r } | tst.ts:292:23:294:5 | [BlockStmt] { ... r } | semmle.order | 2 | -| tst.ts:292:9:292:20 | [BinaryExpr] kind === "a" | tst.ts:292:9:292:12 | [VarRef] kind | semmle.label | 1 | -| tst.ts:292:9:292:20 | [BinaryExpr] kind === "a" | tst.ts:292:9:292:12 | [VarRef] kind | semmle.order | 1 | -| tst.ts:292:9:292:20 | [BinaryExpr] kind === "a" | tst.ts:292:18:292:20 | [Literal] "a" | semmle.label | 2 | -| tst.ts:292:9:292:20 | [BinaryExpr] kind === "a" | tst.ts:292:18:292:20 | [Literal] "a" | semmle.order | 2 | -| tst.ts:292:23:294:5 | [BlockStmt] { ... r } | tst.ts:293:7:293:24 | [ExprStmt] payload.toFixed(); | semmle.label | 1 | -| tst.ts:292:23:294:5 | [BlockStmt] { ... r } | tst.ts:293:7:293:24 | [ExprStmt] payload.toFixed(); | semmle.order | 1 | -| tst.ts:293:7:293:21 | [DotExpr] payload.toFixed | tst.ts:293:7:293:13 | [VarRef] payload | semmle.label | 1 | -| tst.ts:293:7:293:21 | [DotExpr] payload.toFixed | tst.ts:293:7:293:13 | [VarRef] payload | semmle.order | 1 | -| tst.ts:293:7:293:21 | [DotExpr] payload.toFixed | tst.ts:293:15:293:21 | [Label] toFixed | semmle.label | 2 | -| tst.ts:293:7:293:21 | [DotExpr] payload.toFixed | tst.ts:293:15:293:21 | [Label] toFixed | semmle.order | 2 | -| tst.ts:293:7:293:23 | [MethodCallExpr] payload.toFixed() | tst.ts:293:7:293:21 | [DotExpr] payload.toFixed | semmle.label | 0 | -| tst.ts:293:7:293:23 | [MethodCallExpr] payload.toFixed() | tst.ts:293:7:293:21 | [DotExpr] payload.toFixed | semmle.order | 0 | -| tst.ts:293:7:293:24 | [ExprStmt] payload.toFixed(); | tst.ts:293:7:293:23 | [MethodCallExpr] payload.toFixed() | semmle.label | 1 | -| tst.ts:293:7:293:24 | [ExprStmt] payload.toFixed(); | tst.ts:293:7:293:23 | [MethodCallExpr] payload.toFixed() | semmle.order | 1 | -| tst.ts:298:1:298:21 | [DeclStmt] const key = ... | tst.ts:298:7:298:20 | [VariableDeclarator] key = Symbol() | semmle.label | 1 | -| tst.ts:298:1:298:21 | [DeclStmt] const key = ... | tst.ts:298:7:298:20 | [VariableDeclarator] key = Symbol() | semmle.order | 1 | -| tst.ts:298:7:298:20 | [VariableDeclarator] key = Symbol() | tst.ts:298:7:298:9 | [VarDecl] key | semmle.label | 1 | -| tst.ts:298:7:298:20 | [VariableDeclarator] key = Symbol() | tst.ts:298:7:298:9 | [VarDecl] key | semmle.order | 1 | -| tst.ts:298:7:298:20 | [VariableDeclarator] key = Symbol() | tst.ts:298:13:298:20 | [CallExpr] Symbol() | semmle.label | 2 | -| tst.ts:298:7:298:20 | [VariableDeclarator] key = Symbol() | tst.ts:298:13:298:20 | [CallExpr] Symbol() | semmle.order | 2 | -| tst.ts:298:13:298:20 | [CallExpr] Symbol() | tst.ts:298:13:298:18 | [VarRef] Symbol | semmle.label | 0 | -| tst.ts:298:13:298:20 | [CallExpr] Symbol() | tst.ts:298:13:298:18 | [VarRef] Symbol | semmle.order | 0 | -| tst.ts:300:1:300:58 | [DeclStmt] const numberOrString = ... | tst.ts:300:7:300:57 | [VariableDeclarator] numberO ... "hello" | semmle.label | 1 | -| tst.ts:300:1:300:58 | [DeclStmt] const numberOrString = ... | tst.ts:300:7:300:57 | [VariableDeclarator] numberO ... "hello" | semmle.order | 1 | -| tst.ts:300:7:300:57 | [VariableDeclarator] numberO ... "hello" | tst.ts:300:7:300:20 | [VarDecl] numberOrString | semmle.label | 1 | -| tst.ts:300:7:300:57 | [VariableDeclarator] numberO ... "hello" | tst.ts:300:7:300:20 | [VarDecl] numberOrString | semmle.order | 1 | -| tst.ts:300:7:300:57 | [VariableDeclarator] numberO ... "hello" | tst.ts:300:24:300:57 | [ConditionalExpr] Math.ra ... "hello" | semmle.label | 2 | -| tst.ts:300:7:300:57 | [VariableDeclarator] numberO ... "hello" | tst.ts:300:24:300:57 | [ConditionalExpr] Math.ra ... "hello" | semmle.order | 2 | -| tst.ts:300:24:300:34 | [DotExpr] Math.random | tst.ts:300:24:300:27 | [VarRef] Math | semmle.label | 1 | -| tst.ts:300:24:300:34 | [DotExpr] Math.random | tst.ts:300:24:300:27 | [VarRef] Math | semmle.order | 1 | -| tst.ts:300:24:300:34 | [DotExpr] Math.random | tst.ts:300:29:300:34 | [Label] random | semmle.label | 2 | -| tst.ts:300:24:300:34 | [DotExpr] Math.random | tst.ts:300:29:300:34 | [Label] random | semmle.order | 2 | -| tst.ts:300:24:300:36 | [MethodCallExpr] Math.random() | tst.ts:300:24:300:34 | [DotExpr] Math.random | semmle.label | 0 | -| tst.ts:300:24:300:36 | [MethodCallExpr] Math.random() | tst.ts:300:24:300:34 | [DotExpr] Math.random | semmle.order | 0 | -| tst.ts:300:24:300:42 | [BinaryExpr] Math.random() < 0.5 | tst.ts:300:24:300:36 | [MethodCallExpr] Math.random() | semmle.label | 1 | -| tst.ts:300:24:300:42 | [BinaryExpr] Math.random() < 0.5 | tst.ts:300:24:300:36 | [MethodCallExpr] Math.random() | semmle.order | 1 | -| tst.ts:300:24:300:42 | [BinaryExpr] Math.random() < 0.5 | tst.ts:300:40:300:42 | [Literal] 0.5 | semmle.label | 2 | -| tst.ts:300:24:300:42 | [BinaryExpr] Math.random() < 0.5 | tst.ts:300:40:300:42 | [Literal] 0.5 | semmle.order | 2 | -| tst.ts:300:24:300:57 | [ConditionalExpr] Math.ra ... "hello" | tst.ts:300:24:300:42 | [BinaryExpr] Math.random() < 0.5 | semmle.label | 1 | -| tst.ts:300:24:300:57 | [ConditionalExpr] Math.ra ... "hello" | tst.ts:300:24:300:42 | [BinaryExpr] Math.random() < 0.5 | semmle.order | 1 | -| tst.ts:300:24:300:57 | [ConditionalExpr] Math.ra ... "hello" | tst.ts:300:46:300:47 | [Literal] 42 | semmle.label | 2 | -| tst.ts:300:24:300:57 | [ConditionalExpr] Math.ra ... "hello" | tst.ts:300:46:300:47 | [Literal] 42 | semmle.order | 2 | -| tst.ts:300:24:300:57 | [ConditionalExpr] Math.ra ... "hello" | tst.ts:300:51:300:57 | [Literal] "hello" | semmle.label | 3 | -| tst.ts:300:24:300:57 | [ConditionalExpr] Math.ra ... "hello" | tst.ts:300:51:300:57 | [Literal] "hello" | semmle.order | 3 | -| tst.ts:302:1:304:2 | [DeclStmt] let obj = ... | tst.ts:302:5:304:1 | [VariableDeclarator] obj = { ... ring, } | semmle.label | 1 | -| tst.ts:302:1:304:2 | [DeclStmt] let obj = ... | tst.ts:302:5:304:1 | [VariableDeclarator] obj = { ... ring, } | semmle.order | 1 | -| tst.ts:302:5:304:1 | [VariableDeclarator] obj = { ... ring, } | tst.ts:302:5:302:7 | [VarDecl] obj | semmle.label | 1 | -| tst.ts:302:5:304:1 | [VariableDeclarator] obj = { ... ring, } | tst.ts:302:5:302:7 | [VarDecl] obj | semmle.order | 1 | -| tst.ts:302:5:304:1 | [VariableDeclarator] obj = { ... ring, } | tst.ts:302:11:304:1 | [ObjectExpr] { [ke ... ring, } | semmle.label | 2 | -| tst.ts:302:5:304:1 | [VariableDeclarator] obj = { ... ring, } | tst.ts:302:11:304:1 | [ObjectExpr] { [ke ... ring, } | semmle.order | 2 | -| tst.ts:302:11:304:1 | [ObjectExpr] { [ke ... ring, } | tst.ts:303:3:303:23 | [Property] [key]: ... rString | semmle.label | 1 | -| tst.ts:302:11:304:1 | [ObjectExpr] { [ke ... ring, } | tst.ts:303:3:303:23 | [Property] [key]: ... rString | semmle.order | 1 | -| tst.ts:303:3:303:23 | [Property] [key]: ... rString | tst.ts:303:4:303:6 | [VarRef] key | semmle.label | 1 | -| tst.ts:303:3:303:23 | [Property] [key]: ... rString | tst.ts:303:4:303:6 | [VarRef] key | semmle.order | 1 | -| tst.ts:303:3:303:23 | [Property] [key]: ... rString | tst.ts:303:10:303:23 | [VarRef] numberOrString | semmle.label | 2 | -| tst.ts:303:3:303:23 | [Property] [key]: ... rString | tst.ts:303:10:303:23 | [VarRef] numberOrString | semmle.order | 2 | -| tst.ts:306:1:309:1 | [IfStmt] if (typ ... se(); } | tst.ts:306:5:306:32 | [BinaryExpr] typeof ... string" | semmle.label | 1 | -| tst.ts:306:1:309:1 | [IfStmt] if (typ ... se(); } | tst.ts:306:5:306:32 | [BinaryExpr] typeof ... string" | semmle.order | 1 | -| tst.ts:306:1:309:1 | [IfStmt] if (typ ... se(); } | tst.ts:306:35:309:1 | [BlockStmt] { let ... se(); } | semmle.label | 2 | -| tst.ts:306:1:309:1 | [IfStmt] if (typ ... se(); } | tst.ts:306:35:309:1 | [BlockStmt] { let ... se(); } | semmle.order | 2 | -| tst.ts:306:5:306:19 | [UnaryExpr] typeof obj[key] | tst.ts:306:12:306:19 | [IndexExpr] obj[key] | semmle.label | 1 | -| tst.ts:306:5:306:19 | [UnaryExpr] typeof obj[key] | tst.ts:306:12:306:19 | [IndexExpr] obj[key] | semmle.order | 1 | -| tst.ts:306:5:306:32 | [BinaryExpr] typeof ... string" | tst.ts:306:5:306:19 | [UnaryExpr] typeof obj[key] | semmle.label | 1 | -| tst.ts:306:5:306:32 | [BinaryExpr] typeof ... string" | tst.ts:306:5:306:19 | [UnaryExpr] typeof obj[key] | semmle.order | 1 | -| tst.ts:306:5:306:32 | [BinaryExpr] typeof ... string" | tst.ts:306:25:306:32 | [Literal] "string" | semmle.label | 2 | -| tst.ts:306:5:306:32 | [BinaryExpr] typeof ... string" | tst.ts:306:25:306:32 | [Literal] "string" | semmle.order | 2 | -| tst.ts:306:12:306:19 | [IndexExpr] obj[key] | tst.ts:306:12:306:14 | [VarRef] obj | semmle.label | 1 | -| tst.ts:306:12:306:19 | [IndexExpr] obj[key] | tst.ts:306:12:306:14 | [VarRef] obj | semmle.order | 1 | -| tst.ts:306:12:306:19 | [IndexExpr] obj[key] | tst.ts:306:16:306:18 | [VarRef] key | semmle.label | 2 | -| tst.ts:306:12:306:19 | [IndexExpr] obj[key] | tst.ts:306:16:306:18 | [VarRef] key | semmle.order | 2 | -| tst.ts:306:35:309:1 | [BlockStmt] { let ... se(); } | tst.ts:307:3:307:21 | [DeclStmt] let str = ... | semmle.label | 1 | -| tst.ts:306:35:309:1 | [BlockStmt] { let ... se(); } | tst.ts:307:3:307:21 | [DeclStmt] let str = ... | semmle.order | 1 | -| tst.ts:306:35:309:1 | [BlockStmt] { let ... se(); } | tst.ts:308:3:308:20 | [ExprStmt] str.toUpperCase(); | semmle.label | 2 | -| tst.ts:306:35:309:1 | [BlockStmt] { let ... se(); } | tst.ts:308:3:308:20 | [ExprStmt] str.toUpperCase(); | semmle.order | 2 | -| tst.ts:307:3:307:21 | [DeclStmt] let str = ... | tst.ts:307:7:307:20 | [VariableDeclarator] str = obj[key] | semmle.label | 1 | -| tst.ts:307:3:307:21 | [DeclStmt] let str = ... | tst.ts:307:7:307:20 | [VariableDeclarator] str = obj[key] | semmle.order | 1 | -| tst.ts:307:7:307:20 | [VariableDeclarator] str = obj[key] | tst.ts:307:7:307:9 | [VarDecl] str | semmle.label | 1 | -| tst.ts:307:7:307:20 | [VariableDeclarator] str = obj[key] | tst.ts:307:7:307:9 | [VarDecl] str | semmle.order | 1 | -| tst.ts:307:7:307:20 | [VariableDeclarator] str = obj[key] | tst.ts:307:13:307:20 | [IndexExpr] obj[key] | semmle.label | 2 | -| tst.ts:307:7:307:20 | [VariableDeclarator] str = obj[key] | tst.ts:307:13:307:20 | [IndexExpr] obj[key] | semmle.order | 2 | -| tst.ts:307:13:307:20 | [IndexExpr] obj[key] | tst.ts:307:13:307:15 | [VarRef] obj | semmle.label | 1 | -| tst.ts:307:13:307:20 | [IndexExpr] obj[key] | tst.ts:307:13:307:15 | [VarRef] obj | semmle.order | 1 | -| tst.ts:307:13:307:20 | [IndexExpr] obj[key] | tst.ts:307:17:307:19 | [VarRef] key | semmle.label | 2 | -| tst.ts:307:13:307:20 | [IndexExpr] obj[key] | tst.ts:307:17:307:19 | [VarRef] key | semmle.order | 2 | -| tst.ts:308:3:308:17 | [DotExpr] str.toUpperCase | tst.ts:308:3:308:5 | [VarRef] str | semmle.label | 1 | -| tst.ts:308:3:308:17 | [DotExpr] str.toUpperCase | tst.ts:308:3:308:5 | [VarRef] str | semmle.order | 1 | -| tst.ts:308:3:308:17 | [DotExpr] str.toUpperCase | tst.ts:308:7:308:17 | [Label] toUpperCase | semmle.label | 2 | -| tst.ts:308:3:308:17 | [DotExpr] str.toUpperCase | tst.ts:308:7:308:17 | [Label] toUpperCase | semmle.order | 2 | -| tst.ts:308:3:308:19 | [MethodCallExpr] str.toUpperCase() | tst.ts:308:3:308:17 | [DotExpr] str.toUpperCase | semmle.label | 0 | -| tst.ts:308:3:308:19 | [MethodCallExpr] str.toUpperCase() | tst.ts:308:3:308:17 | [DotExpr] str.toUpperCase | semmle.order | 0 | -| tst.ts:308:3:308:20 | [ExprStmt] str.toUpperCase(); | tst.ts:308:3:308:19 | [MethodCallExpr] str.toUpperCase() | semmle.label | 1 | -| tst.ts:308:3:308:20 | [ExprStmt] str.toUpperCase(); | tst.ts:308:3:308:19 | [MethodCallExpr] str.toUpperCase() | semmle.order | 1 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | file://:0:0:0:0 | (TypeParameters) | semmle.label | 2 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | file://:0:0:0:0 | (TypeParameters) | semmle.order | 2 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | tst.ts:313:10:313:10 | [VarDecl] f | semmle.label | 0 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | tst.ts:313:10:313:10 | [VarDecl] f | semmle.order | 0 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | tst.ts:316:4:316:7 | [KeywordTypeExpr] void | semmle.label | 4 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | tst.ts:316:4:316:7 | [KeywordTypeExpr] void | semmle.order | 4 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | tst.ts:316:9:316:10 | [BlockStmt] {} | semmle.label | 5 | -| tst.ts:313:1:316:10 | [FunctionDeclStmt] functio ... void {} | tst.ts:316:9:316:10 | [BlockStmt] {} | semmle.order | 5 | -| tst.ts:313:12:313:12 | [TypeParameter] T | tst.ts:313:12:313:12 | [Identifier] T | semmle.label | 1 | -| tst.ts:313:12:313:12 | [TypeParameter] T | tst.ts:313:12:313:12 | [Identifier] T | semmle.order | 1 | -| tst.ts:313:15:313:17 | [SimpleParameter] arg | tst.ts:313:20:315:27 | [InterfaceTypeExpr] { pro ... void } | semmle.label | -2 | -| tst.ts:313:15:313:17 | [SimpleParameter] arg | tst.ts:313:20:315:27 | [InterfaceTypeExpr] { pro ... void } | semmle.order | -2 | -| tst.ts:313:20:315:27 | [InterfaceTypeExpr] { pro ... void } | tst.ts:314:3:314:28 | [FieldDeclaration] produce ... ) => T, | semmle.label | 1 | -| tst.ts:313:20:315:27 | [InterfaceTypeExpr] { pro ... void } | tst.ts:314:3:314:28 | [FieldDeclaration] produce ... ) => T, | semmle.order | 1 | -| tst.ts:313:20:315:27 | [InterfaceTypeExpr] { pro ... void } | tst.ts:315:3:315:25 | [FieldDeclaration] consume ... => void | semmle.label | 2 | -| tst.ts:313:20:315:27 | [InterfaceTypeExpr] { pro ... void } | tst.ts:315:3:315:25 | [FieldDeclaration] consume ... => void | semmle.order | 2 | -| tst.ts:314:3:314:28 | [FieldDeclaration] produce ... ) => T, | tst.ts:314:3:314:9 | [Label] produce | semmle.label | 1 | -| tst.ts:314:3:314:28 | [FieldDeclaration] produce ... ) => T, | tst.ts:314:3:314:9 | [Label] produce | semmle.order | 1 | -| tst.ts:314:3:314:28 | [FieldDeclaration] produce ... ) => T, | tst.ts:314:12:314:27 | [FunctionTypeExpr] (n: string) => T | semmle.label | 2 | -| tst.ts:314:3:314:28 | [FieldDeclaration] produce ... ) => T, | tst.ts:314:12:314:27 | [FunctionTypeExpr] (n: string) => T | semmle.order | 2 | -| tst.ts:314:12:314:27 | [FunctionExpr] (n: string) => T | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:314:12:314:27 | [FunctionExpr] (n: string) => T | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:314:12:314:27 | [FunctionExpr] (n: string) => T | tst.ts:314:27:314:27 | [LocalTypeAccess] T | semmle.label | 4 | -| tst.ts:314:12:314:27 | [FunctionExpr] (n: string) => T | tst.ts:314:27:314:27 | [LocalTypeAccess] T | semmle.order | 4 | -| tst.ts:314:12:314:27 | [FunctionTypeExpr] (n: string) => T | tst.ts:314:12:314:27 | [FunctionExpr] (n: string) => T | semmle.label | 1 | -| tst.ts:314:12:314:27 | [FunctionTypeExpr] (n: string) => T | tst.ts:314:12:314:27 | [FunctionExpr] (n: string) => T | semmle.order | 1 | -| tst.ts:314:13:314:13 | [SimpleParameter] n | tst.ts:314:16:314:21 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:314:13:314:13 | [SimpleParameter] n | tst.ts:314:16:314:21 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:315:3:315:25 | [FieldDeclaration] consume ... => void | tst.ts:315:3:315:9 | [Label] consume | semmle.label | 1 | -| tst.ts:315:3:315:25 | [FieldDeclaration] consume ... => void | tst.ts:315:3:315:9 | [Label] consume | semmle.order | 1 | -| tst.ts:315:3:315:25 | [FieldDeclaration] consume ... => void | tst.ts:315:12:315:25 | [FunctionTypeExpr] (x: T) => void | semmle.label | 2 | -| tst.ts:315:3:315:25 | [FieldDeclaration] consume ... => void | tst.ts:315:12:315:25 | [FunctionTypeExpr] (x: T) => void | semmle.order | 2 | -| tst.ts:315:12:315:25 | [FunctionExpr] (x: T) => void | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:315:12:315:25 | [FunctionExpr] (x: T) => void | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:315:12:315:25 | [FunctionExpr] (x: T) => void | tst.ts:315:22:315:25 | [KeywordTypeExpr] void | semmle.label | 4 | -| tst.ts:315:12:315:25 | [FunctionExpr] (x: T) => void | tst.ts:315:22:315:25 | [KeywordTypeExpr] void | semmle.order | 4 | -| tst.ts:315:12:315:25 | [FunctionTypeExpr] (x: T) => void | tst.ts:315:12:315:25 | [FunctionExpr] (x: T) => void | semmle.label | 1 | -| tst.ts:315:12:315:25 | [FunctionTypeExpr] (x: T) => void | tst.ts:315:12:315:25 | [FunctionExpr] (x: T) => void | semmle.order | 1 | -| tst.ts:315:13:315:13 | [SimpleParameter] x | tst.ts:315:16:315:16 | [LocalTypeAccess] T | semmle.label | -2 | -| tst.ts:315:13:315:13 | [SimpleParameter] x | tst.ts:315:16:315:16 | [LocalTypeAccess] T | semmle.order | -2 | -| tst.ts:318:1:321:2 | [CallExpr] f({ p ... se() }) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:318:1:321:2 | [CallExpr] f({ p ... se() }) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:318:1:321:2 | [CallExpr] f({ p ... se() }) | tst.ts:318:1:318:1 | [VarRef] f | semmle.label | 0 | -| tst.ts:318:1:321:2 | [CallExpr] f({ p ... se() }) | tst.ts:318:1:318:1 | [VarRef] f | semmle.order | 0 | -| tst.ts:318:1:321:3 | [ExprStmt] f({ p ... e() }); | tst.ts:318:1:321:2 | [CallExpr] f({ p ... se() }) | semmle.label | 1 | -| tst.ts:318:1:321:3 | [ExprStmt] f({ p ... e() }); | tst.ts:318:1:321:2 | [CallExpr] f({ p ... se() }) | semmle.order | 1 | -| tst.ts:318:3:321:1 | [ObjectExpr] {produce: ...} | tst.ts:319:3:319:17 | [Property] produce: n => n | semmle.label | 1 | -| tst.ts:318:3:321:1 | [ObjectExpr] {produce: ...} | tst.ts:319:3:319:17 | [Property] produce: n => n | semmle.order | 1 | -| tst.ts:318:3:321:1 | [ObjectExpr] {produce: ...} | tst.ts:320:3:320:31 | [Property] consume ... rCase() | semmle.label | 2 | -| tst.ts:318:3:321:1 | [ObjectExpr] {produce: ...} | tst.ts:320:3:320:31 | [Property] consume ... rCase() | semmle.order | 2 | -| tst.ts:319:3:319:17 | [Property] produce: n => n | tst.ts:319:3:319:9 | [Label] produce | semmle.label | 1 | -| tst.ts:319:3:319:17 | [Property] produce: n => n | tst.ts:319:3:319:9 | [Label] produce | semmle.order | 1 | -| tst.ts:319:3:319:17 | [Property] produce: n => n | tst.ts:319:12:319:17 | [ArrowFunctionExpr] n => n | semmle.label | 2 | -| tst.ts:319:3:319:17 | [Property] produce: n => n | tst.ts:319:12:319:17 | [ArrowFunctionExpr] n => n | semmle.order | 2 | -| tst.ts:319:12:319:17 | [ArrowFunctionExpr] n => n | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:319:12:319:17 | [ArrowFunctionExpr] n => n | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:319:12:319:17 | [ArrowFunctionExpr] n => n | tst.ts:319:17:319:17 | [VarRef] n | semmle.label | 5 | -| tst.ts:319:12:319:17 | [ArrowFunctionExpr] n => n | tst.ts:319:17:319:17 | [VarRef] n | semmle.order | 5 | -| tst.ts:320:3:320:31 | [Property] consume ... rCase() | tst.ts:320:3:320:9 | [Label] consume | semmle.label | 1 | -| tst.ts:320:3:320:31 | [Property] consume ... rCase() | tst.ts:320:3:320:9 | [Label] consume | semmle.order | 1 | -| tst.ts:320:3:320:31 | [Property] consume ... rCase() | tst.ts:320:12:320:31 | [ArrowFunctionExpr] x => x.toLowerCase() | semmle.label | 2 | -| tst.ts:320:3:320:31 | [Property] consume ... rCase() | tst.ts:320:12:320:31 | [ArrowFunctionExpr] x => x.toLowerCase() | semmle.order | 2 | -| tst.ts:320:12:320:31 | [ArrowFunctionExpr] x => x.toLowerCase() | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:320:12:320:31 | [ArrowFunctionExpr] x => x.toLowerCase() | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:320:12:320:31 | [ArrowFunctionExpr] x => x.toLowerCase() | tst.ts:320:17:320:31 | [MethodCallExpr] x.toLowerCase() | semmle.label | 5 | -| tst.ts:320:12:320:31 | [ArrowFunctionExpr] x => x.toLowerCase() | tst.ts:320:17:320:31 | [MethodCallExpr] x.toLowerCase() | semmle.order | 5 | -| tst.ts:320:17:320:29 | [DotExpr] x.toLowerCase | tst.ts:320:17:320:17 | [VarRef] x | semmle.label | 1 | -| tst.ts:320:17:320:29 | [DotExpr] x.toLowerCase | tst.ts:320:17:320:17 | [VarRef] x | semmle.order | 1 | -| tst.ts:320:17:320:29 | [DotExpr] x.toLowerCase | tst.ts:320:19:320:29 | [Label] toLowerCase | semmle.label | 2 | -| tst.ts:320:17:320:29 | [DotExpr] x.toLowerCase | tst.ts:320:19:320:29 | [Label] toLowerCase | semmle.order | 2 | -| tst.ts:320:17:320:31 | [MethodCallExpr] x.toLowerCase() | tst.ts:320:17:320:29 | [DotExpr] x.toLowerCase | semmle.label | 0 | -| tst.ts:320:17:320:31 | [MethodCallExpr] x.toLowerCase() | tst.ts:320:17:320:29 | [DotExpr] x.toLowerCase | semmle.order | 0 | -| tst.ts:325:1:325:36 | [DeclStmt] const ErrorMap = ... | tst.ts:325:7:325:35 | [VariableDeclarator] ErrorMa ... Error> | semmle.label | 1 | -| tst.ts:325:1:325:36 | [DeclStmt] const ErrorMap = ... | tst.ts:325:7:325:35 | [VariableDeclarator] ErrorMa ... Error> | semmle.order | 1 | -| tst.ts:325:7:325:35 | [VariableDeclarator] ErrorMa ... Error> | tst.ts:325:7:325:14 | [VarDecl] ErrorMap | semmle.label | 1 | -| tst.ts:325:7:325:35 | [VariableDeclarator] ErrorMa ... Error> | tst.ts:325:7:325:14 | [VarDecl] ErrorMap | semmle.order | 1 | -| tst.ts:325:7:325:35 | [VariableDeclarator] ErrorMa ... Error> | tst.ts:325:18:325:35 | [ExpressionWithTypeArguments] Map | semmle.label | 2 | -| tst.ts:325:7:325:35 | [VariableDeclarator] ErrorMa ... Error> | tst.ts:325:18:325:35 | [ExpressionWithTypeArguments] Map | semmle.order | 2 | -| tst.ts:325:18:325:35 | [ExpressionWithTypeArguments] Map | tst.ts:325:18:325:20 | [VarRef] Map | semmle.label | 1 | -| tst.ts:325:18:325:35 | [ExpressionWithTypeArguments] Map | tst.ts:325:18:325:20 | [VarRef] Map | semmle.order | 1 | -| tst.ts:325:18:325:35 | [ExpressionWithTypeArguments] Map | tst.ts:325:22:325:27 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:325:18:325:35 | [ExpressionWithTypeArguments] Map | tst.ts:325:22:325:27 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:325:18:325:35 | [ExpressionWithTypeArguments] Map | tst.ts:325:30:325:34 | [LocalTypeAccess] Error | semmle.label | 3 | -| tst.ts:325:18:325:35 | [ExpressionWithTypeArguments] Map | tst.ts:325:30:325:34 | [LocalTypeAccess] Error | semmle.order | 3 | -| tst.ts:327:1:327:32 | [DeclStmt] const errorMap = ... | tst.ts:327:7:327:31 | [VariableDeclarator] errorMa ... orMap() | semmle.label | 1 | -| tst.ts:327:1:327:32 | [DeclStmt] const errorMap = ... | tst.ts:327:7:327:31 | [VariableDeclarator] errorMa ... orMap() | semmle.order | 1 | -| tst.ts:327:7:327:31 | [VariableDeclarator] errorMa ... orMap() | tst.ts:327:7:327:14 | [VarDecl] errorMap | semmle.label | 1 | -| tst.ts:327:7:327:31 | [VariableDeclarator] errorMa ... orMap() | tst.ts:327:7:327:14 | [VarDecl] errorMap | semmle.order | 1 | -| tst.ts:327:7:327:31 | [VariableDeclarator] errorMa ... orMap() | tst.ts:327:18:327:31 | [NewExpr] new ErrorMap() | semmle.label | 2 | -| tst.ts:327:7:327:31 | [VariableDeclarator] errorMa ... orMap() | tst.ts:327:18:327:31 | [NewExpr] new ErrorMap() | semmle.order | 2 | -| tst.ts:327:18:327:31 | [NewExpr] new ErrorMap() | tst.ts:327:22:327:29 | [VarRef] ErrorMap | semmle.label | 0 | -| tst.ts:327:18:327:31 | [NewExpr] new ErrorMap() | tst.ts:327:22:327:29 | [VarRef] ErrorMap | semmle.order | 0 | -| tst.ts:331:1:334:14 | [TypeAliasDeclaration,TypeDefinition] type Fi ... never; | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| tst.ts:331:1:334:14 | [TypeAliasDeclaration,TypeDefinition] type Fi ... never; | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| tst.ts:331:1:334:14 | [TypeAliasDeclaration,TypeDefinition] type Fi ... never; | tst.ts:331:6:331:16 | [Identifier] FirstString | semmle.label | 1 | -| tst.ts:331:1:334:14 | [TypeAliasDeclaration,TypeDefinition] type Fi ... never; | tst.ts:331:6:331:16 | [Identifier] FirstString | semmle.order | 1 | -| tst.ts:331:1:334:14 | [TypeAliasDeclaration,TypeDefinition] type Fi ... never; | tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | semmle.label | 3 | -| tst.ts:331:1:334:14 | [TypeAliasDeclaration,TypeDefinition] type Fi ... never; | tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | semmle.order | 3 | -| tst.ts:331:18:331:18 | [TypeParameter] T | tst.ts:331:18:331:18 | [Identifier] T | semmle.label | 1 | -| tst.ts:331:18:331:18 | [TypeParameter] T | tst.ts:331:18:331:18 | [Identifier] T | semmle.order | 1 | -| tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | tst.ts:332:3:332:3 | [LocalTypeAccess] T | semmle.label | 1 | -| tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | tst.ts:332:3:332:3 | [LocalTypeAccess] T | semmle.order | 1 | -| tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | tst.ts:332:13:332:50 | [TupleTypeExpr] [infer ... nown[]] | semmle.label | 2 | -| tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | tst.ts:332:13:332:50 | [TupleTypeExpr] [infer ... nown[]] | semmle.order | 2 | -| tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | tst.ts:333:9:333:9 | [LocalTypeAccess] S | semmle.label | 3 | -| tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | tst.ts:333:9:333:9 | [LocalTypeAccess] S | semmle.order | 3 | -| tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | tst.ts:334:9:334:13 | [KeywordTypeExpr] never | semmle.label | 4 | -| tst.ts:332:3:334:13 | [ConditionalTypeExpr] T exten ... : never | tst.ts:334:9:334:13 | [KeywordTypeExpr] never | semmle.order | 4 | -| tst.ts:332:13:332:50 | [TupleTypeExpr] [infer ... nown[]] | tst.ts:332:14:332:35 | [InferTypeExpr] infer S ... string | semmle.label | 1 | -| tst.ts:332:13:332:50 | [TupleTypeExpr] [infer ... nown[]] | tst.ts:332:14:332:35 | [InferTypeExpr] infer S ... string | semmle.order | 1 | -| tst.ts:332:13:332:50 | [TupleTypeExpr] [infer ... nown[]] | tst.ts:332:38:332:49 | [RestTypeExpr] ...unknown[] | semmle.label | 2 | -| tst.ts:332:13:332:50 | [TupleTypeExpr] [infer ... nown[]] | tst.ts:332:38:332:49 | [RestTypeExpr] ...unknown[] | semmle.order | 2 | -| tst.ts:332:14:332:35 | [InferTypeExpr] infer S ... string | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| tst.ts:332:14:332:35 | [InferTypeExpr] infer S ... string | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| tst.ts:332:20:332:35 | [TypeParameter] S extends string | tst.ts:332:20:332:20 | [Identifier] S | semmle.label | 1 | -| tst.ts:332:20:332:35 | [TypeParameter] S extends string | tst.ts:332:20:332:20 | [Identifier] S | semmle.order | 1 | -| tst.ts:332:20:332:35 | [TypeParameter] S extends string | tst.ts:332:30:332:35 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:332:20:332:35 | [TypeParameter] S extends string | tst.ts:332:30:332:35 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:332:38:332:49 | [RestTypeExpr] ...unknown[] | tst.ts:332:41:332:49 | [ArrayTypeExpr] unknown[] | semmle.label | 1 | -| tst.ts:332:38:332:49 | [RestTypeExpr] ...unknown[] | tst.ts:332:41:332:49 | [ArrayTypeExpr] unknown[] | semmle.order | 1 | -| tst.ts:332:41:332:49 | [ArrayTypeExpr] unknown[] | tst.ts:332:41:332:47 | [KeywordTypeExpr] unknown | semmle.label | 1 | -| tst.ts:332:41:332:49 | [ArrayTypeExpr] unknown[] | tst.ts:332:41:332:47 | [KeywordTypeExpr] unknown | semmle.order | 1 | -| tst.ts:336:1:336:51 | [TypeAliasDeclaration,TypeDefinition] type F ... lean]>; | tst.ts:336:6:336:6 | [Identifier] F | semmle.label | 1 | -| tst.ts:336:1:336:51 | [TypeAliasDeclaration,TypeDefinition] type F ... lean]>; | tst.ts:336:6:336:6 | [Identifier] F | semmle.order | 1 | -| tst.ts:336:1:336:51 | [TypeAliasDeclaration,TypeDefinition] type F ... lean]>; | tst.ts:336:10:336:50 | [GenericTypeExpr] FirstSt ... olean]> | semmle.label | 2 | -| tst.ts:336:1:336:51 | [TypeAliasDeclaration,TypeDefinition] type F ... lean]>; | tst.ts:336:10:336:50 | [GenericTypeExpr] FirstSt ... olean]> | semmle.order | 2 | -| tst.ts:336:10:336:50 | [GenericTypeExpr] FirstSt ... olean]> | tst.ts:336:10:336:20 | [LocalTypeAccess] FirstString | semmle.label | 1 | -| tst.ts:336:10:336:50 | [GenericTypeExpr] FirstSt ... olean]> | tst.ts:336:10:336:20 | [LocalTypeAccess] FirstString | semmle.order | 1 | -| tst.ts:336:10:336:50 | [GenericTypeExpr] FirstSt ... olean]> | tst.ts:336:22:336:49 | [TupleTypeExpr] ['a' \| ... oolean] | semmle.label | 2 | -| tst.ts:336:10:336:50 | [GenericTypeExpr] FirstSt ... olean]> | tst.ts:336:22:336:49 | [TupleTypeExpr] ['a' \| ... oolean] | semmle.order | 2 | -| tst.ts:336:22:336:49 | [TupleTypeExpr] ['a' \| ... oolean] | tst.ts:336:23:336:31 | [UnionTypeExpr] 'a' \| 'b' | semmle.label | 1 | -| tst.ts:336:22:336:49 | [TupleTypeExpr] ['a' \| ... oolean] | tst.ts:336:23:336:31 | [UnionTypeExpr] 'a' \| 'b' | semmle.order | 1 | -| tst.ts:336:22:336:49 | [TupleTypeExpr] ['a' \| ... oolean] | tst.ts:336:34:336:39 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:336:22:336:49 | [TupleTypeExpr] ['a' \| ... oolean] | tst.ts:336:34:336:39 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:336:22:336:49 | [TupleTypeExpr] ['a' \| ... oolean] | tst.ts:336:42:336:48 | [KeywordTypeExpr] boolean | semmle.label | 3 | -| tst.ts:336:22:336:49 | [TupleTypeExpr] ['a' \| ... oolean] | tst.ts:336:42:336:48 | [KeywordTypeExpr] boolean | semmle.order | 3 | -| tst.ts:336:23:336:31 | [UnionTypeExpr] 'a' \| 'b' | tst.ts:336:23:336:25 | [LiteralTypeExpr] 'a' | semmle.label | 1 | -| tst.ts:336:23:336:31 | [UnionTypeExpr] 'a' \| 'b' | tst.ts:336:23:336:25 | [LiteralTypeExpr] 'a' | semmle.order | 1 | -| tst.ts:336:23:336:31 | [UnionTypeExpr] 'a' \| 'b' | tst.ts:336:29:336:31 | [LiteralTypeExpr] 'b' | semmle.label | 2 | -| tst.ts:336:23:336:31 | [UnionTypeExpr] 'a' \| 'b' | tst.ts:336:29:336:31 | [LiteralTypeExpr] 'b' | semmle.order | 2 | -| tst.ts:338:1:338:17 | [DeclStmt] const a = ... | tst.ts:338:7:338:16 | [VariableDeclarator] a: F = 'a' | semmle.label | 1 | -| tst.ts:338:1:338:17 | [DeclStmt] const a = ... | tst.ts:338:7:338:16 | [VariableDeclarator] a: F = 'a' | semmle.order | 1 | -| tst.ts:338:7:338:16 | [VariableDeclarator] a: F = 'a' | tst.ts:338:7:338:7 | [VarDecl] a | semmle.label | 1 | -| tst.ts:338:7:338:16 | [VariableDeclarator] a: F = 'a' | tst.ts:338:7:338:7 | [VarDecl] a | semmle.order | 1 | -| tst.ts:338:7:338:16 | [VariableDeclarator] a: F = 'a' | tst.ts:338:10:338:10 | [LocalTypeAccess] F | semmle.label | 2 | -| tst.ts:338:7:338:16 | [VariableDeclarator] a: F = 'a' | tst.ts:338:10:338:10 | [LocalTypeAccess] F | semmle.order | 2 | -| tst.ts:338:7:338:16 | [VariableDeclarator] a: F = 'a' | tst.ts:338:14:338:16 | [Literal] 'a' | semmle.label | 3 | -| tst.ts:338:7:338:16 | [VariableDeclarator] a: F = 'a' | tst.ts:338:14:338:16 | [Literal] 'a' | semmle.order | 3 | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | tst.ts:342:11:342:15 | [Identifier] State | semmle.label | 1 | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | tst.ts:342:11:342:15 | [Identifier] State | semmle.order | 1 | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | tst.ts:343:3:343:15 | [FieldDeclaration] get: () => T; | semmle.label | 3 | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | tst.ts:343:3:343:15 | [FieldDeclaration] get: () => T; | semmle.order | 3 | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | tst.ts:344:3:344:26 | [FieldDeclaration] set: (v ... > void; | semmle.label | 4 | -| tst.ts:342:1:345:1 | [InterfaceDeclaration,TypeDefinition] interfa ... void; } | tst.ts:344:3:344:26 | [FieldDeclaration] set: (v ... > void; | semmle.order | 4 | -| tst.ts:342:17:342:24 | [TypeParameter] in out T | tst.ts:342:24:342:24 | [Identifier] T | semmle.label | 1 | -| tst.ts:342:17:342:24 | [TypeParameter] in out T | tst.ts:342:24:342:24 | [Identifier] T | semmle.order | 1 | -| tst.ts:343:3:343:15 | [FieldDeclaration] get: () => T; | tst.ts:343:3:343:5 | [Label] get | semmle.label | 1 | -| tst.ts:343:3:343:15 | [FieldDeclaration] get: () => T; | tst.ts:343:3:343:5 | [Label] get | semmle.order | 1 | -| tst.ts:343:3:343:15 | [FieldDeclaration] get: () => T; | tst.ts:343:8:343:14 | [FunctionTypeExpr] () => T | semmle.label | 2 | -| tst.ts:343:3:343:15 | [FieldDeclaration] get: () => T; | tst.ts:343:8:343:14 | [FunctionTypeExpr] () => T | semmle.order | 2 | -| tst.ts:343:8:343:14 | [FunctionExpr] () => T | tst.ts:343:14:343:14 | [LocalTypeAccess] T | semmle.label | 4 | -| tst.ts:343:8:343:14 | [FunctionExpr] () => T | tst.ts:343:14:343:14 | [LocalTypeAccess] T | semmle.order | 4 | -| tst.ts:343:8:343:14 | [FunctionTypeExpr] () => T | tst.ts:343:8:343:14 | [FunctionExpr] () => T | semmle.label | 1 | -| tst.ts:343:8:343:14 | [FunctionTypeExpr] () => T | tst.ts:343:8:343:14 | [FunctionExpr] () => T | semmle.order | 1 | -| tst.ts:344:3:344:26 | [FieldDeclaration] set: (v ... > void; | tst.ts:344:3:344:5 | [Label] set | semmle.label | 1 | -| tst.ts:344:3:344:26 | [FieldDeclaration] set: (v ... > void; | tst.ts:344:3:344:5 | [Label] set | semmle.order | 1 | -| tst.ts:344:3:344:26 | [FieldDeclaration] set: (v ... > void; | tst.ts:344:8:344:25 | [FunctionTypeExpr] (value: T) => void | semmle.label | 2 | -| tst.ts:344:3:344:26 | [FieldDeclaration] set: (v ... > void; | tst.ts:344:8:344:25 | [FunctionTypeExpr] (value: T) => void | semmle.order | 2 | -| tst.ts:344:8:344:25 | [FunctionExpr] (value: T) => void | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:344:8:344:25 | [FunctionExpr] (value: T) => void | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:344:8:344:25 | [FunctionExpr] (value: T) => void | tst.ts:344:22:344:25 | [KeywordTypeExpr] void | semmle.label | 4 | -| tst.ts:344:8:344:25 | [FunctionExpr] (value: T) => void | tst.ts:344:22:344:25 | [KeywordTypeExpr] void | semmle.order | 4 | -| tst.ts:344:8:344:25 | [FunctionTypeExpr] (value: T) => void | tst.ts:344:8:344:25 | [FunctionExpr] (value: T) => void | semmle.label | 1 | -| tst.ts:344:8:344:25 | [FunctionTypeExpr] (value: T) => void | tst.ts:344:8:344:25 | [FunctionExpr] (value: T) => void | semmle.order | 1 | -| tst.ts:344:9:344:13 | [SimpleParameter] value | tst.ts:344:16:344:16 | [LocalTypeAccess] T | semmle.label | -2 | -| tst.ts:344:9:344:13 | [SimpleParameter] value | tst.ts:344:16:344:16 | [LocalTypeAccess] T | semmle.order | -2 | -| tst.ts:347:1:350:1 | [DeclStmt] const state = ... | tst.ts:347:7:350:1 | [VariableDeclarator] state: ... > { } } | semmle.label | 1 | -| tst.ts:347:1:350:1 | [DeclStmt] const state = ... | tst.ts:347:7:350:1 | [VariableDeclarator] state: ... > { } } | semmle.order | 1 | -| tst.ts:347:7:350:1 | [VariableDeclarator] state: ... > { } } | tst.ts:347:7:347:11 | [VarDecl] state | semmle.label | 1 | -| tst.ts:347:7:350:1 | [VariableDeclarator] state: ... > { } } | tst.ts:347:7:347:11 | [VarDecl] state | semmle.order | 1 | -| tst.ts:347:7:350:1 | [VariableDeclarator] state: ... > { } } | tst.ts:347:14:347:26 | [GenericTypeExpr] State | semmle.label | 2 | -| tst.ts:347:7:350:1 | [VariableDeclarator] state: ... > { } } | tst.ts:347:14:347:26 | [GenericTypeExpr] State | semmle.order | 2 | -| tst.ts:347:7:350:1 | [VariableDeclarator] state: ... > { } } | tst.ts:347:30:350:1 | [ObjectExpr] {get: ...} | semmle.label | 3 | -| tst.ts:347:7:350:1 | [VariableDeclarator] state: ... > { } } | tst.ts:347:30:350:1 | [ObjectExpr] {get: ...} | semmle.order | 3 | -| tst.ts:347:14:347:26 | [GenericTypeExpr] State | tst.ts:347:14:347:18 | [LocalTypeAccess] State | semmle.label | 1 | -| tst.ts:347:14:347:26 | [GenericTypeExpr] State | tst.ts:347:14:347:18 | [LocalTypeAccess] State | semmle.order | 1 | -| tst.ts:347:14:347:26 | [GenericTypeExpr] State | tst.ts:347:20:347:25 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:347:14:347:26 | [GenericTypeExpr] State | tst.ts:347:20:347:25 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:347:30:350:1 | [ObjectExpr] {get: ...} | tst.ts:348:3:348:15 | [Property] get: () => 42 | semmle.label | 1 | -| tst.ts:347:30:350:1 | [ObjectExpr] {get: ...} | tst.ts:348:3:348:15 | [Property] get: () => 42 | semmle.order | 1 | -| tst.ts:347:30:350:1 | [ObjectExpr] {get: ...} | tst.ts:349:3:349:21 | [Property] set: (value) => { } | semmle.label | 2 | -| tst.ts:347:30:350:1 | [ObjectExpr] {get: ...} | tst.ts:349:3:349:21 | [Property] set: (value) => { } | semmle.order | 2 | -| tst.ts:348:3:348:15 | [Property] get: () => 42 | tst.ts:348:3:348:5 | [Label] get | semmle.label | 1 | -| tst.ts:348:3:348:15 | [Property] get: () => 42 | tst.ts:348:3:348:5 | [Label] get | semmle.order | 1 | -| tst.ts:348:3:348:15 | [Property] get: () => 42 | tst.ts:348:8:348:15 | [ArrowFunctionExpr] () => 42 | semmle.label | 2 | -| tst.ts:348:3:348:15 | [Property] get: () => 42 | tst.ts:348:8:348:15 | [ArrowFunctionExpr] () => 42 | semmle.order | 2 | -| tst.ts:348:8:348:15 | [ArrowFunctionExpr] () => 42 | tst.ts:348:14:348:15 | [Literal] 42 | semmle.label | 5 | -| tst.ts:348:8:348:15 | [ArrowFunctionExpr] () => 42 | tst.ts:348:14:348:15 | [Literal] 42 | semmle.order | 5 | -| tst.ts:349:3:349:21 | [Property] set: (value) => { } | tst.ts:349:3:349:5 | [Label] set | semmle.label | 1 | -| tst.ts:349:3:349:21 | [Property] set: (value) => { } | tst.ts:349:3:349:5 | [Label] set | semmle.order | 1 | -| tst.ts:349:3:349:21 | [Property] set: (value) => { } | tst.ts:349:8:349:21 | [ArrowFunctionExpr] (value) => { } | semmle.label | 2 | -| tst.ts:349:3:349:21 | [Property] set: (value) => { } | tst.ts:349:8:349:21 | [ArrowFunctionExpr] (value) => { } | semmle.order | 2 | -| tst.ts:349:8:349:21 | [ArrowFunctionExpr] (value) => { } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:349:8:349:21 | [ArrowFunctionExpr] (value) => { } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:349:8:349:21 | [ArrowFunctionExpr] (value) => { } | tst.ts:349:19:349:21 | [BlockStmt] { } | semmle.label | 5 | -| tst.ts:349:8:349:21 | [ArrowFunctionExpr] (value) => { } | tst.ts:349:19:349:21 | [BlockStmt] { } | semmle.order | 5 | -| tst.ts:352:1:352:29 | [DeclStmt] const fortyTwo = ... | tst.ts:352:7:352:28 | [VariableDeclarator] fortyTw ... e.get() | semmle.label | 1 | -| tst.ts:352:1:352:29 | [DeclStmt] const fortyTwo = ... | tst.ts:352:7:352:28 | [VariableDeclarator] fortyTw ... e.get() | semmle.order | 1 | -| tst.ts:352:7:352:28 | [VariableDeclarator] fortyTw ... e.get() | tst.ts:352:7:352:14 | [VarDecl] fortyTwo | semmle.label | 1 | -| tst.ts:352:7:352:28 | [VariableDeclarator] fortyTw ... e.get() | tst.ts:352:7:352:14 | [VarDecl] fortyTwo | semmle.order | 1 | -| tst.ts:352:7:352:28 | [VariableDeclarator] fortyTw ... e.get() | tst.ts:352:18:352:28 | [MethodCallExpr] state.get() | semmle.label | 2 | -| tst.ts:352:7:352:28 | [VariableDeclarator] fortyTw ... e.get() | tst.ts:352:18:352:28 | [MethodCallExpr] state.get() | semmle.order | 2 | -| tst.ts:352:18:352:26 | [DotExpr] state.get | tst.ts:352:18:352:22 | [VarRef] state | semmle.label | 1 | -| tst.ts:352:18:352:26 | [DotExpr] state.get | tst.ts:352:18:352:22 | [VarRef] state | semmle.order | 1 | -| tst.ts:352:18:352:26 | [DotExpr] state.get | tst.ts:352:24:352:26 | [Label] get | semmle.label | 2 | -| tst.ts:352:18:352:26 | [DotExpr] state.get | tst.ts:352:24:352:26 | [Label] get | semmle.order | 2 | -| tst.ts:352:18:352:28 | [MethodCallExpr] state.get() | tst.ts:352:18:352:26 | [DotExpr] state.get | semmle.label | 0 | -| tst.ts:352:18:352:28 | [MethodCallExpr] state.get() | tst.ts:352:18:352:26 | [DotExpr] state.get | semmle.order | 0 | -| tst.ts:356:1:356:44 | [ImportDeclaration] import ... S.mjs'; | tst.ts:356:8:356:18 | [ImportSpecifier] tstModuleES | semmle.label | 1 | -| tst.ts:356:1:356:44 | [ImportDeclaration] import ... S.mjs'; | tst.ts:356:8:356:18 | [ImportSpecifier] tstModuleES | semmle.order | 1 | -| tst.ts:356:1:356:44 | [ImportDeclaration] import ... S.mjs'; | tst.ts:356:25:356:43 | [Literal] './tstModuleES.mjs' | semmle.label | 2 | -| tst.ts:356:1:356:44 | [ImportDeclaration] import ... S.mjs'; | tst.ts:356:25:356:43 | [Literal] './tstModuleES.mjs' | semmle.order | 2 | -| tst.ts:356:8:356:18 | [ImportSpecifier] tstModuleES | tst.ts:356:8:356:18 | [VarDecl] tstModuleES | semmle.label | 1 | -| tst.ts:356:8:356:18 | [ImportSpecifier] tstModuleES | tst.ts:356:8:356:18 | [VarDecl] tstModuleES | semmle.order | 1 | -| tst.ts:358:1:358:11 | [DotExpr] console.log | tst.ts:358:1:358:7 | [VarRef] console | semmle.label | 1 | -| tst.ts:358:1:358:11 | [DotExpr] console.log | tst.ts:358:1:358:7 | [VarRef] console | semmle.order | 1 | -| tst.ts:358:1:358:11 | [DotExpr] console.log | tst.ts:358:9:358:11 | [Label] log | semmle.label | 2 | -| tst.ts:358:1:358:11 | [DotExpr] console.log | tst.ts:358:9:358:11 | [Label] log | semmle.order | 2 | -| tst.ts:358:1:358:26 | [MethodCallExpr] console ... leES()) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:358:1:358:26 | [MethodCallExpr] console ... leES()) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:358:1:358:26 | [MethodCallExpr] console ... leES()) | tst.ts:358:1:358:11 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:358:1:358:26 | [MethodCallExpr] console ... leES()) | tst.ts:358:1:358:11 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:358:1:358:27 | [ExprStmt] console ... eES()); | tst.ts:358:1:358:26 | [MethodCallExpr] console ... leES()) | semmle.label | 1 | -| tst.ts:358:1:358:27 | [ExprStmt] console ... eES()); | tst.ts:358:1:358:26 | [MethodCallExpr] console ... leES()) | semmle.order | 1 | -| tst.ts:358:13:358:25 | [CallExpr] tstModuleES() | tst.ts:358:13:358:23 | [VarRef] tstModuleES | semmle.label | 0 | -| tst.ts:358:13:358:25 | [CallExpr] tstModuleES() | tst.ts:358:13:358:23 | [VarRef] tstModuleES | semmle.order | 0 | -| tst.ts:360:1:360:50 | [ImportDeclaration] import ... S.cjs'; | tst.ts:360:10:360:21 | [ImportSpecifier] tstModuleCJS | semmle.label | 1 | -| tst.ts:360:1:360:50 | [ImportDeclaration] import ... S.cjs'; | tst.ts:360:10:360:21 | [ImportSpecifier] tstModuleCJS | semmle.order | 1 | -| tst.ts:360:1:360:50 | [ImportDeclaration] import ... S.cjs'; | tst.ts:360:30:360:49 | [Literal] './tstModuleCJS.cjs' | semmle.label | 2 | -| tst.ts:360:1:360:50 | [ImportDeclaration] import ... S.cjs'; | tst.ts:360:30:360:49 | [Literal] './tstModuleCJS.cjs' | semmle.order | 2 | -| tst.ts:360:10:360:21 | [ImportSpecifier] tstModuleCJS | tst.ts:360:10:360:21 | [Label] tstModuleCJS | semmle.label | 1 | -| tst.ts:360:10:360:21 | [ImportSpecifier] tstModuleCJS | tst.ts:360:10:360:21 | [Label] tstModuleCJS | semmle.order | 1 | -| tst.ts:360:10:360:21 | [ImportSpecifier] tstModuleCJS | tst.ts:360:10:360:21 | [VarDecl] tstModuleCJS | semmle.label | 2 | -| tst.ts:360:10:360:21 | [ImportSpecifier] tstModuleCJS | tst.ts:360:10:360:21 | [VarDecl] tstModuleCJS | semmle.order | 2 | -| tst.ts:362:1:362:11 | [DotExpr] console.log | tst.ts:362:1:362:7 | [VarRef] console | semmle.label | 1 | -| tst.ts:362:1:362:11 | [DotExpr] console.log | tst.ts:362:1:362:7 | [VarRef] console | semmle.order | 1 | -| tst.ts:362:1:362:11 | [DotExpr] console.log | tst.ts:362:9:362:11 | [Label] log | semmle.label | 2 | -| tst.ts:362:1:362:11 | [DotExpr] console.log | tst.ts:362:9:362:11 | [Label] log | semmle.order | 2 | -| tst.ts:362:1:362:27 | [MethodCallExpr] console ... eCJS()) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:362:1:362:27 | [MethodCallExpr] console ... eCJS()) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:362:1:362:27 | [MethodCallExpr] console ... eCJS()) | tst.ts:362:1:362:11 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:362:1:362:27 | [MethodCallExpr] console ... eCJS()) | tst.ts:362:1:362:11 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:362:1:362:28 | [ExprStmt] console ... CJS()); | tst.ts:362:1:362:27 | [MethodCallExpr] console ... eCJS()) | semmle.label | 1 | -| tst.ts:362:1:362:28 | [ExprStmt] console ... CJS()); | tst.ts:362:1:362:27 | [MethodCallExpr] console ... eCJS()) | semmle.order | 1 | -| tst.ts:362:13:362:26 | [CallExpr] tstModuleCJS() | tst.ts:362:13:362:24 | [VarRef] tstModuleCJS | semmle.label | 0 | -| tst.ts:362:13:362:26 | [CallExpr] tstModuleCJS() | tst.ts:362:13:362:24 | [VarRef] tstModuleCJS | semmle.order | 0 | -| tst.ts:368:1:368:34 | [ImportDeclaration] import ... ffixA'; | tst.ts:368:8:368:13 | [ImportSpecifier] * as A | semmle.label | 1 | -| tst.ts:368:1:368:34 | [ImportDeclaration] import ... ffixA'; | tst.ts:368:8:368:13 | [ImportSpecifier] * as A | semmle.order | 1 | -| tst.ts:368:1:368:34 | [ImportDeclaration] import ... ffixA'; | tst.ts:368:20:368:33 | [Literal] './tstSuffixA' | semmle.label | 2 | -| tst.ts:368:1:368:34 | [ImportDeclaration] import ... ffixA'; | tst.ts:368:20:368:33 | [Literal] './tstSuffixA' | semmle.order | 2 | -| tst.ts:368:8:368:13 | [ImportSpecifier] * as A | tst.ts:368:13:368:13 | [VarDecl] A | semmle.label | 1 | -| tst.ts:368:8:368:13 | [ImportSpecifier] * as A | tst.ts:368:13:368:13 | [VarDecl] A | semmle.order | 1 | -| tst.ts:370:1:370:11 | [DotExpr] console.log | tst.ts:370:1:370:7 | [VarRef] console | semmle.label | 1 | -| tst.ts:370:1:370:11 | [DotExpr] console.log | tst.ts:370:1:370:7 | [VarRef] console | semmle.order | 1 | -| tst.ts:370:1:370:11 | [DotExpr] console.log | tst.ts:370:9:370:11 | [Label] log | semmle.label | 2 | -| tst.ts:370:1:370:11 | [DotExpr] console.log | tst.ts:370:9:370:11 | [Label] log | semmle.order | 2 | -| tst.ts:370:1:370:29 | [MethodCallExpr] console ... File()) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:370:1:370:29 | [MethodCallExpr] console ... File()) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:370:1:370:29 | [MethodCallExpr] console ... File()) | tst.ts:370:1:370:11 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:370:1:370:29 | [MethodCallExpr] console ... File()) | tst.ts:370:1:370:11 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:370:1:370:30 | [ExprStmt] console ... ile()); | tst.ts:370:1:370:29 | [MethodCallExpr] console ... File()) | semmle.label | 1 | -| tst.ts:370:1:370:30 | [ExprStmt] console ... ile()); | tst.ts:370:1:370:29 | [MethodCallExpr] console ... File()) | semmle.order | 1 | -| tst.ts:370:13:370:26 | [DotExpr] A.resolvedFile | tst.ts:370:13:370:13 | [VarRef] A | semmle.label | 1 | -| tst.ts:370:13:370:26 | [DotExpr] A.resolvedFile | tst.ts:370:13:370:13 | [VarRef] A | semmle.order | 1 | -| tst.ts:370:13:370:26 | [DotExpr] A.resolvedFile | tst.ts:370:15:370:26 | [Label] resolvedFile | semmle.label | 2 | -| tst.ts:370:13:370:26 | [DotExpr] A.resolvedFile | tst.ts:370:15:370:26 | [Label] resolvedFile | semmle.order | 2 | -| tst.ts:370:13:370:28 | [MethodCallExpr] A.resolvedFile() | tst.ts:370:13:370:26 | [DotExpr] A.resolvedFile | semmle.label | 0 | -| tst.ts:370:13:370:28 | [MethodCallExpr] A.resolvedFile() | tst.ts:370:13:370:26 | [DotExpr] A.resolvedFile | semmle.order | 0 | -| tst.ts:372:1:372:34 | [ImportDeclaration] import ... ffixB'; | tst.ts:372:8:372:13 | [ImportSpecifier] * as B | semmle.label | 1 | -| tst.ts:372:1:372:34 | [ImportDeclaration] import ... ffixB'; | tst.ts:372:8:372:13 | [ImportSpecifier] * as B | semmle.order | 1 | -| tst.ts:372:1:372:34 | [ImportDeclaration] import ... ffixB'; | tst.ts:372:20:372:33 | [Literal] './tstSuffixB' | semmle.label | 2 | -| tst.ts:372:1:372:34 | [ImportDeclaration] import ... ffixB'; | tst.ts:372:20:372:33 | [Literal] './tstSuffixB' | semmle.order | 2 | -| tst.ts:372:8:372:13 | [ImportSpecifier] * as B | tst.ts:372:13:372:13 | [VarDecl] B | semmle.label | 1 | -| tst.ts:372:8:372:13 | [ImportSpecifier] * as B | tst.ts:372:13:372:13 | [VarDecl] B | semmle.order | 1 | -| tst.ts:374:1:374:11 | [DotExpr] console.log | tst.ts:374:1:374:7 | [VarRef] console | semmle.label | 1 | -| tst.ts:374:1:374:11 | [DotExpr] console.log | tst.ts:374:1:374:7 | [VarRef] console | semmle.order | 1 | -| tst.ts:374:1:374:11 | [DotExpr] console.log | tst.ts:374:9:374:11 | [Label] log | semmle.label | 2 | -| tst.ts:374:1:374:11 | [DotExpr] console.log | tst.ts:374:9:374:11 | [Label] log | semmle.order | 2 | -| tst.ts:374:1:374:29 | [MethodCallExpr] console ... File()) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:374:1:374:29 | [MethodCallExpr] console ... File()) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:374:1:374:29 | [MethodCallExpr] console ... File()) | tst.ts:374:1:374:11 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:374:1:374:29 | [MethodCallExpr] console ... File()) | tst.ts:374:1:374:11 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:374:1:374:30 | [ExprStmt] console ... ile()); | tst.ts:374:1:374:29 | [MethodCallExpr] console ... File()) | semmle.label | 1 | -| tst.ts:374:1:374:30 | [ExprStmt] console ... ile()); | tst.ts:374:1:374:29 | [MethodCallExpr] console ... File()) | semmle.order | 1 | -| tst.ts:374:13:374:26 | [DotExpr] B.resolvedFile | tst.ts:374:13:374:13 | [VarRef] B | semmle.label | 1 | -| tst.ts:374:13:374:26 | [DotExpr] B.resolvedFile | tst.ts:374:13:374:13 | [VarRef] B | semmle.order | 1 | -| tst.ts:374:13:374:26 | [DotExpr] B.resolvedFile | tst.ts:374:15:374:26 | [Label] resolvedFile | semmle.label | 2 | -| tst.ts:374:13:374:26 | [DotExpr] B.resolvedFile | tst.ts:374:15:374:26 | [Label] resolvedFile | semmle.order | 2 | -| tst.ts:374:13:374:28 | [MethodCallExpr] B.resolvedFile() | tst.ts:374:13:374:26 | [DotExpr] B.resolvedFile | semmle.label | 0 | -| tst.ts:374:13:374:28 | [MethodCallExpr] B.resolvedFile() | tst.ts:374:13:374:26 | [DotExpr] B.resolvedFile | semmle.order | 0 | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | tst.ts:379:8:379:11 | [VarDecl] TS48 | semmle.label | 1 | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | tst.ts:379:8:379:11 | [VarDecl] TS48 | semmle.order | 1 | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | tst.ts:381:5:381:73 | [TypeAliasDeclaration,TypeDefinition] type So ... never; | semmle.label | 2 | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | tst.ts:381:5:381:73 | [TypeAliasDeclaration,TypeDefinition] type So ... never; | semmle.order | 2 | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | semmle.label | 3 | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | semmle.order | 3 | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | tst.ts:385:5:385:74 | [DeclStmt] let [a, ... ye!"]); | semmle.label | 4 | -| tst.ts:379:1:386:1 | [NamespaceDeclaration] module ... ; } | tst.ts:385:5:385:74 | [DeclStmt] let [a, ... ye!"]); | semmle.order | 4 | -| tst.ts:381:5:381:73 | [TypeAliasDeclaration,TypeDefinition] type So ... never; | tst.ts:381:10:381:16 | [Identifier] SomeNum | semmle.label | 1 | -| tst.ts:381:5:381:73 | [TypeAliasDeclaration,TypeDefinition] type So ... never; | tst.ts:381:10:381:16 | [Identifier] SomeNum | semmle.order | 1 | -| tst.ts:381:5:381:73 | [TypeAliasDeclaration,TypeDefinition] type So ... never; | tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | semmle.label | 2 | -| tst.ts:381:5:381:73 | [TypeAliasDeclaration,TypeDefinition] type So ... never; | tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | semmle.order | 2 | -| tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | tst.ts:381:20:381:24 | [LiteralTypeExpr] "100" | semmle.label | 1 | -| tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | tst.ts:381:20:381:24 | [LiteralTypeExpr] "100" | semmle.order | 1 | -| tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | tst.ts:381:34:381:60 | [TemplateLiteralTypeExpr] `${infe ... umber}` | semmle.label | 2 | -| tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | tst.ts:381:34:381:60 | [TemplateLiteralTypeExpr] `${infe ... umber}` | semmle.order | 2 | -| tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | tst.ts:381:64:381:64 | [LocalTypeAccess] U | semmle.label | 3 | -| tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | tst.ts:381:64:381:64 | [LocalTypeAccess] U | semmle.order | 3 | -| tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | tst.ts:381:68:381:72 | [KeywordTypeExpr] never | semmle.label | 4 | -| tst.ts:381:20:381:72 | [ConditionalTypeExpr] "100" e ... : never | tst.ts:381:68:381:72 | [KeywordTypeExpr] never | semmle.order | 4 | -| tst.ts:381:34:381:60 | [TemplateLiteralTypeExpr] `${infe ... umber}` | tst.ts:381:37:381:58 | [InferTypeExpr] infer U ... number | semmle.label | 1 | -| tst.ts:381:34:381:60 | [TemplateLiteralTypeExpr] `${infe ... umber}` | tst.ts:381:37:381:58 | [InferTypeExpr] infer U ... number | semmle.order | 1 | -| tst.ts:381:37:381:58 | [InferTypeExpr] infer U ... number | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| tst.ts:381:37:381:58 | [InferTypeExpr] infer U ... number | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| tst.ts:381:43:381:58 | [TypeParameter] U extends number | tst.ts:381:43:381:43 | [Identifier] U | semmle.label | 1 | -| tst.ts:381:43:381:58 | [TypeParameter] U extends number | tst.ts:381:43:381:43 | [Identifier] U | semmle.order | 1 | -| tst.ts:381:43:381:58 | [TypeParameter] U extends number | tst.ts:381:53:381:58 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:381:43:381:58 | [TypeParameter] U extends number | tst.ts:381:53:381:58 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | file://:0:0:0:0 | (TypeParameters) | semmle.label | 2 | -| tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | file://:0:0:0:0 | (TypeParameters) | semmle.order | 2 | -| tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | tst.ts:383:22:383:35 | [VarDecl] chooseRandomly | semmle.label | 0 | -| tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | tst.ts:383:22:383:35 | [VarDecl] chooseRandomly | semmle.order | 0 | -| tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | tst.ts:383:53:383:53 | [LocalTypeAccess] T | semmle.label | 4 | -| tst.ts:383:5:383:54 | [FunctionDeclStmt] declare ... T): T; | tst.ts:383:53:383:53 | [LocalTypeAccess] T | semmle.order | 4 | -| tst.ts:383:37:383:37 | [TypeParameter] T | tst.ts:383:37:383:37 | [Identifier] T | semmle.label | 1 | -| tst.ts:383:37:383:37 | [TypeParameter] T | tst.ts:383:37:383:37 | [Identifier] T | semmle.order | 1 | -| tst.ts:383:40:383:40 | [SimpleParameter] x | tst.ts:383:43:383:43 | [LocalTypeAccess] T | semmle.label | -2 | -| tst.ts:383:40:383:40 | [SimpleParameter] x | tst.ts:383:43:383:43 | [LocalTypeAccess] T | semmle.order | -2 | -| tst.ts:383:46:383:46 | [SimpleParameter] y | tst.ts:383:49:383:49 | [LocalTypeAccess] T | semmle.label | -2 | -| tst.ts:383:46:383:46 | [SimpleParameter] y | tst.ts:383:49:383:49 | [LocalTypeAccess] T | semmle.order | -2 | -| tst.ts:385:5:385:74 | [DeclStmt] let [a, ... ye!"]); | tst.ts:385:9:385:73 | [VariableDeclarator] [a, b, ... bye!"]) | semmle.label | 1 | -| tst.ts:385:5:385:74 | [DeclStmt] let [a, ... ye!"]); | tst.ts:385:9:385:73 | [VariableDeclarator] [a, b, ... bye!"]) | semmle.order | 1 | -| tst.ts:385:9:385:17 | [ArrayPattern] [a, b, c] | tst.ts:385:10:385:10 | [VarDecl] a | semmle.label | 1 | -| tst.ts:385:9:385:17 | [ArrayPattern] [a, b, c] | tst.ts:385:10:385:10 | [VarDecl] a | semmle.order | 1 | -| tst.ts:385:9:385:17 | [ArrayPattern] [a, b, c] | tst.ts:385:13:385:13 | [VarDecl] b | semmle.label | 2 | -| tst.ts:385:9:385:17 | [ArrayPattern] [a, b, c] | tst.ts:385:13:385:13 | [VarDecl] b | semmle.order | 2 | -| tst.ts:385:9:385:17 | [ArrayPattern] [a, b, c] | tst.ts:385:16:385:16 | [VarDecl] c | semmle.label | 3 | -| tst.ts:385:9:385:17 | [ArrayPattern] [a, b, c] | tst.ts:385:16:385:16 | [VarDecl] c | semmle.order | 3 | -| tst.ts:385:9:385:73 | [VariableDeclarator] [a, b, ... bye!"]) | tst.ts:385:9:385:17 | [ArrayPattern] [a, b, c] | semmle.label | 1 | -| tst.ts:385:9:385:73 | [VariableDeclarator] [a, b, ... bye!"]) | tst.ts:385:9:385:17 | [ArrayPattern] [a, b, c] | semmle.order | 1 | -| tst.ts:385:9:385:73 | [VariableDeclarator] [a, b, ... bye!"]) | tst.ts:385:21:385:73 | [CallExpr] chooseR ... bye!"]) | semmle.label | 2 | -| tst.ts:385:9:385:73 | [VariableDeclarator] [a, b, ... bye!"]) | tst.ts:385:21:385:73 | [CallExpr] chooseR ... bye!"]) | semmle.order | 2 | -| tst.ts:385:21:385:73 | [CallExpr] chooseR ... bye!"]) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:385:21:385:73 | [CallExpr] chooseR ... bye!"]) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:385:21:385:73 | [CallExpr] chooseR ... bye!"]) | tst.ts:385:21:385:34 | [VarRef] chooseRandomly | semmle.label | 0 | -| tst.ts:385:21:385:73 | [CallExpr] chooseR ... bye!"]) | tst.ts:385:21:385:34 | [VarRef] chooseRandomly | semmle.order | 0 | -| tst.ts:385:36:385:52 | [ArrayExpr] [42, true, "hi!"] | tst.ts:385:37:385:38 | [Literal] 42 | semmle.label | 1 | -| tst.ts:385:36:385:52 | [ArrayExpr] [42, true, "hi!"] | tst.ts:385:37:385:38 | [Literal] 42 | semmle.order | 1 | -| tst.ts:385:36:385:52 | [ArrayExpr] [42, true, "hi!"] | tst.ts:385:41:385:44 | [Literal] true | semmle.label | 2 | -| tst.ts:385:36:385:52 | [ArrayExpr] [42, true, "hi!"] | tst.ts:385:41:385:44 | [Literal] true | semmle.order | 2 | -| tst.ts:385:36:385:52 | [ArrayExpr] [42, true, "hi!"] | tst.ts:385:47:385:51 | [Literal] "hi!" | semmle.label | 3 | -| tst.ts:385:36:385:52 | [ArrayExpr] [42, true, "hi!"] | tst.ts:385:47:385:51 | [Literal] "hi!" | semmle.order | 3 | -| tst.ts:385:55:385:72 | [ArrayExpr] [0, false, "bye!"] | tst.ts:385:56:385:56 | [Literal] 0 | semmle.label | 1 | -| tst.ts:385:55:385:72 | [ArrayExpr] [0, false, "bye!"] | tst.ts:385:56:385:56 | [Literal] 0 | semmle.order | 1 | -| tst.ts:385:55:385:72 | [ArrayExpr] [0, false, "bye!"] | tst.ts:385:59:385:63 | [Literal] false | semmle.label | 2 | -| tst.ts:385:55:385:72 | [ArrayExpr] [0, false, "bye!"] | tst.ts:385:59:385:63 | [Literal] false | semmle.order | 2 | -| tst.ts:385:55:385:72 | [ArrayExpr] [0, false, "bye!"] | tst.ts:385:66:385:71 | [Literal] "bye!" | semmle.label | 3 | -| tst.ts:385:55:385:72 | [ArrayExpr] [0, false, "bye!"] | tst.ts:385:66:385:71 | [Literal] "bye!" | semmle.order | 3 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:390:8:390:11 | [VarDecl] TS49 | semmle.label | 1 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:390:8:390:11 | [VarDecl] TS49 | semmle.order | 1 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:391:3:391:41 | [TypeAliasDeclaration,TypeDefinition] type Co ... "blue"; | semmle.label | 2 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:391:3:391:41 | [TypeAliasDeclaration,TypeDefinition] type Co ... "blue"; | semmle.order | 2 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:393:3:393:56 | [TypeAliasDeclaration,TypeDefinition] type RG ... umber]; | semmle.label | 3 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:393:3:393:56 | [TypeAliasDeclaration,TypeDefinition] type RG ... umber]; | semmle.order | 3 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:395:3:399:43 | [DeclStmt] const palette = ... | semmle.label | 4 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:395:3:399:43 | [DeclStmt] const palette = ... | semmle.order | 4 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:402:3:402:41 | [DeclStmt] const redComponent = ... | semmle.label | 5 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:402:3:402:41 | [DeclStmt] const redComponent = ... | semmle.order | 5 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:404:3:406:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | semmle.label | 6 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:404:3:406:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | semmle.order | 6 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:408:3:410:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | semmle.label | 7 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:408:3:410:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | semmle.order | 7 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:412:3:416:3 | [FunctionDeclStmt] functio ... } } | semmle.label | 8 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:412:3:416:3 | [FunctionDeclStmt] functio ... } } | semmle.order | 8 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:419:3:425:3 | [ClassDefinition,TypeDefinition] class P ... } } | semmle.label | 9 | -| tst.ts:390:1:426:1 | [NamespaceDeclaration] module ... } } } | tst.ts:419:3:425:3 | [ClassDefinition,TypeDefinition] class P ... } } | semmle.order | 9 | -| tst.ts:391:3:391:41 | [TypeAliasDeclaration,TypeDefinition] type Co ... "blue"; | tst.ts:391:8:391:13 | [Identifier] Colors | semmle.label | 1 | -| tst.ts:391:3:391:41 | [TypeAliasDeclaration,TypeDefinition] type Co ... "blue"; | tst.ts:391:8:391:13 | [Identifier] Colors | semmle.order | 1 | -| tst.ts:391:3:391:41 | [TypeAliasDeclaration,TypeDefinition] type Co ... "blue"; | tst.ts:391:17:391:40 | [UnionTypeExpr] "red" \| ... "blue" | semmle.label | 2 | -| tst.ts:391:3:391:41 | [TypeAliasDeclaration,TypeDefinition] type Co ... "blue"; | tst.ts:391:17:391:40 | [UnionTypeExpr] "red" \| ... "blue" | semmle.order | 2 | -| tst.ts:391:17:391:40 | [UnionTypeExpr] "red" \| ... "blue" | tst.ts:391:17:391:21 | [LiteralTypeExpr] "red" | semmle.label | 1 | -| tst.ts:391:17:391:40 | [UnionTypeExpr] "red" \| ... "blue" | tst.ts:391:17:391:21 | [LiteralTypeExpr] "red" | semmle.order | 1 | -| tst.ts:391:17:391:40 | [UnionTypeExpr] "red" \| ... "blue" | tst.ts:391:25:391:31 | [LiteralTypeExpr] "green" | semmle.label | 2 | -| tst.ts:391:17:391:40 | [UnionTypeExpr] "red" \| ... "blue" | tst.ts:391:25:391:31 | [LiteralTypeExpr] "green" | semmle.order | 2 | -| tst.ts:391:17:391:40 | [UnionTypeExpr] "red" \| ... "blue" | tst.ts:391:35:391:40 | [LiteralTypeExpr] "blue" | semmle.label | 3 | -| tst.ts:391:17:391:40 | [UnionTypeExpr] "red" \| ... "blue" | tst.ts:391:35:391:40 | [LiteralTypeExpr] "blue" | semmle.order | 3 | -| tst.ts:393:3:393:56 | [TypeAliasDeclaration,TypeDefinition] type RG ... umber]; | tst.ts:393:8:393:10 | [Identifier] RGB | semmle.label | 1 | -| tst.ts:393:3:393:56 | [TypeAliasDeclaration,TypeDefinition] type RG ... umber]; | tst.ts:393:8:393:10 | [Identifier] RGB | semmle.order | 1 | -| tst.ts:393:3:393:56 | [TypeAliasDeclaration,TypeDefinition] type RG ... umber]; | tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | semmle.label | 2 | -| tst.ts:393:3:393:56 | [TypeAliasDeclaration,TypeDefinition] type RG ... umber]; | tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | semmle.order | 2 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:15:393:17 | [Identifier] red | semmle.label | 1 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:15:393:17 | [Identifier] red | semmle.order | 1 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:20:393:25 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:20:393:25 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:28:393:32 | [Identifier] green | semmle.label | 3 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:28:393:32 | [Identifier] green | semmle.order | 3 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:35:393:40 | [KeywordTypeExpr] number | semmle.label | 4 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:35:393:40 | [KeywordTypeExpr] number | semmle.order | 4 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:43:393:46 | [Identifier] blue | semmle.label | 5 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:43:393:46 | [Identifier] blue | semmle.order | 5 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:49:393:54 | [KeywordTypeExpr] number | semmle.label | 6 | -| tst.ts:393:14:393:55 | [TupleTypeExpr] [red: n ... number] | tst.ts:393:49:393:54 | [KeywordTypeExpr] number | semmle.order | 6 | -| tst.ts:395:3:399:43 | [DeclStmt] const palette = ... | tst.ts:395:9:399:42 | [VariableDeclarator] palette ... \| RGB> | semmle.label | 1 | -| tst.ts:395:3:399:43 | [DeclStmt] const palette = ... | tst.ts:395:9:399:42 | [VariableDeclarator] palette ... \| RGB> | semmle.order | 1 | -| tst.ts:395:9:399:42 | [VariableDeclarator] palette ... \| RGB> | tst.ts:395:9:395:15 | [VarDecl] palette | semmle.label | 1 | -| tst.ts:395:9:399:42 | [VariableDeclarator] palette ... \| RGB> | tst.ts:395:9:395:15 | [VarDecl] palette | semmle.order | 1 | -| tst.ts:395:9:399:42 | [VariableDeclarator] palette ... \| RGB> | tst.ts:395:19:399:42 | [SatisfiesExpr] { r ... \| RGB> | semmle.label | 2 | -| tst.ts:395:9:399:42 | [VariableDeclarator] palette ... \| RGB> | tst.ts:395:19:399:42 | [SatisfiesExpr] { r ... \| RGB> | semmle.order | 2 | -| tst.ts:395:19:399:3 | [ObjectExpr] {red: ...} | tst.ts:396:5:396:20 | [Property] red: [255, 0, 0] | semmle.label | 1 | -| tst.ts:395:19:399:3 | [ObjectExpr] {red: ...} | tst.ts:396:5:396:20 | [Property] red: [255, 0, 0] | semmle.order | 1 | -| tst.ts:395:19:399:3 | [ObjectExpr] {red: ...} | tst.ts:397:5:397:20 | [Property] green: "#00ff00" | semmle.label | 2 | -| tst.ts:395:19:399:3 | [ObjectExpr] {red: ...} | tst.ts:397:5:397:20 | [Property] green: "#00ff00" | semmle.order | 2 | -| tst.ts:395:19:399:3 | [ObjectExpr] {red: ...} | tst.ts:398:5:398:21 | [Property] bleu: [0, 0, 255] | semmle.label | 3 | -| tst.ts:395:19:399:3 | [ObjectExpr] {red: ...} | tst.ts:398:5:398:21 | [Property] bleu: [0, 0, 255] | semmle.order | 3 | -| tst.ts:395:19:399:42 | [SatisfiesExpr] { r ... \| RGB> | tst.ts:395:19:399:3 | [ObjectExpr] {red: ...} | semmle.label | 1 | -| tst.ts:395:19:399:42 | [SatisfiesExpr] { r ... \| RGB> | tst.ts:395:19:399:3 | [ObjectExpr] {red: ...} | semmle.order | 1 | -| tst.ts:395:19:399:42 | [SatisfiesExpr] { r ... \| RGB> | tst.ts:399:15:399:42 | [GenericTypeExpr] Record< ... \| RGB> | semmle.label | 2 | -| tst.ts:395:19:399:42 | [SatisfiesExpr] { r ... \| RGB> | tst.ts:399:15:399:42 | [GenericTypeExpr] Record< ... \| RGB> | semmle.order | 2 | -| tst.ts:396:5:396:20 | [Property] red: [255, 0, 0] | tst.ts:396:5:396:7 | [Label] red | semmle.label | 1 | -| tst.ts:396:5:396:20 | [Property] red: [255, 0, 0] | tst.ts:396:5:396:7 | [Label] red | semmle.order | 1 | -| tst.ts:396:5:396:20 | [Property] red: [255, 0, 0] | tst.ts:396:10:396:20 | [ArrayExpr] [255, 0, 0] | semmle.label | 2 | -| tst.ts:396:5:396:20 | [Property] red: [255, 0, 0] | tst.ts:396:10:396:20 | [ArrayExpr] [255, 0, 0] | semmle.order | 2 | -| tst.ts:396:10:396:20 | [ArrayExpr] [255, 0, 0] | tst.ts:396:11:396:13 | [Literal] 255 | semmle.label | 1 | -| tst.ts:396:10:396:20 | [ArrayExpr] [255, 0, 0] | tst.ts:396:11:396:13 | [Literal] 255 | semmle.order | 1 | -| tst.ts:396:10:396:20 | [ArrayExpr] [255, 0, 0] | tst.ts:396:16:396:16 | [Literal] 0 | semmle.label | 2 | -| tst.ts:396:10:396:20 | [ArrayExpr] [255, 0, 0] | tst.ts:396:16:396:16 | [Literal] 0 | semmle.order | 2 | -| tst.ts:396:10:396:20 | [ArrayExpr] [255, 0, 0] | tst.ts:396:19:396:19 | [Literal] 0 | semmle.label | 3 | -| tst.ts:396:10:396:20 | [ArrayExpr] [255, 0, 0] | tst.ts:396:19:396:19 | [Literal] 0 | semmle.order | 3 | -| tst.ts:397:5:397:20 | [Property] green: "#00ff00" | tst.ts:397:5:397:9 | [Label] green | semmle.label | 1 | -| tst.ts:397:5:397:20 | [Property] green: "#00ff00" | tst.ts:397:5:397:9 | [Label] green | semmle.order | 1 | -| tst.ts:397:5:397:20 | [Property] green: "#00ff00" | tst.ts:397:12:397:20 | [Literal] "#00ff00" | semmle.label | 2 | -| tst.ts:397:5:397:20 | [Property] green: "#00ff00" | tst.ts:397:12:397:20 | [Literal] "#00ff00" | semmle.order | 2 | -| tst.ts:398:5:398:21 | [Property] bleu: [0, 0, 255] | tst.ts:398:5:398:8 | [Label] bleu | semmle.label | 1 | -| tst.ts:398:5:398:21 | [Property] bleu: [0, 0, 255] | tst.ts:398:5:398:8 | [Label] bleu | semmle.order | 1 | -| tst.ts:398:5:398:21 | [Property] bleu: [0, 0, 255] | tst.ts:398:11:398:21 | [ArrayExpr] [0, 0, 255] | semmle.label | 2 | -| tst.ts:398:5:398:21 | [Property] bleu: [0, 0, 255] | tst.ts:398:11:398:21 | [ArrayExpr] [0, 0, 255] | semmle.order | 2 | -| tst.ts:398:11:398:21 | [ArrayExpr] [0, 0, 255] | tst.ts:398:12:398:12 | [Literal] 0 | semmle.label | 1 | -| tst.ts:398:11:398:21 | [ArrayExpr] [0, 0, 255] | tst.ts:398:12:398:12 | [Literal] 0 | semmle.order | 1 | -| tst.ts:398:11:398:21 | [ArrayExpr] [0, 0, 255] | tst.ts:398:15:398:15 | [Literal] 0 | semmle.label | 2 | -| tst.ts:398:11:398:21 | [ArrayExpr] [0, 0, 255] | tst.ts:398:15:398:15 | [Literal] 0 | semmle.order | 2 | -| tst.ts:398:11:398:21 | [ArrayExpr] [0, 0, 255] | tst.ts:398:18:398:20 | [Literal] 255 | semmle.label | 3 | -| tst.ts:398:11:398:21 | [ArrayExpr] [0, 0, 255] | tst.ts:398:18:398:20 | [Literal] 255 | semmle.order | 3 | -| tst.ts:399:15:399:42 | [GenericTypeExpr] Record< ... \| RGB> | tst.ts:399:15:399:20 | [LocalTypeAccess] Record | semmle.label | 1 | -| tst.ts:399:15:399:42 | [GenericTypeExpr] Record< ... \| RGB> | tst.ts:399:15:399:20 | [LocalTypeAccess] Record | semmle.order | 1 | -| tst.ts:399:15:399:42 | [GenericTypeExpr] Record< ... \| RGB> | tst.ts:399:22:399:27 | [LocalTypeAccess] Colors | semmle.label | 2 | -| tst.ts:399:15:399:42 | [GenericTypeExpr] Record< ... \| RGB> | tst.ts:399:22:399:27 | [LocalTypeAccess] Colors | semmle.order | 2 | -| tst.ts:399:15:399:42 | [GenericTypeExpr] Record< ... \| RGB> | tst.ts:399:30:399:41 | [UnionTypeExpr] string \| RGB | semmle.label | 3 | -| tst.ts:399:15:399:42 | [GenericTypeExpr] Record< ... \| RGB> | tst.ts:399:30:399:41 | [UnionTypeExpr] string \| RGB | semmle.order | 3 | -| tst.ts:399:30:399:41 | [UnionTypeExpr] string \| RGB | tst.ts:399:30:399:35 | [KeywordTypeExpr] string | semmle.label | 1 | -| tst.ts:399:30:399:41 | [UnionTypeExpr] string \| RGB | tst.ts:399:30:399:35 | [KeywordTypeExpr] string | semmle.order | 1 | -| tst.ts:399:30:399:41 | [UnionTypeExpr] string \| RGB | tst.ts:399:39:399:41 | [LocalTypeAccess] RGB | semmle.label | 2 | -| tst.ts:399:30:399:41 | [UnionTypeExpr] string \| RGB | tst.ts:399:39:399:41 | [LocalTypeAccess] RGB | semmle.order | 2 | -| tst.ts:402:3:402:41 | [DeclStmt] const redComponent = ... | tst.ts:402:9:402:40 | [VariableDeclarator] redComp ... d.at(0) | semmle.label | 1 | -| tst.ts:402:3:402:41 | [DeclStmt] const redComponent = ... | tst.ts:402:9:402:40 | [VariableDeclarator] redComp ... d.at(0) | semmle.order | 1 | -| tst.ts:402:9:402:40 | [VariableDeclarator] redComp ... d.at(0) | tst.ts:402:9:402:20 | [VarDecl] redComponent | semmle.label | 1 | -| tst.ts:402:9:402:40 | [VariableDeclarator] redComp ... d.at(0) | tst.ts:402:9:402:20 | [VarDecl] redComponent | semmle.order | 1 | -| tst.ts:402:9:402:40 | [VariableDeclarator] redComp ... d.at(0) | tst.ts:402:24:402:40 | [MethodCallExpr] palette.red.at(0) | semmle.label | 2 | -| tst.ts:402:9:402:40 | [VariableDeclarator] redComp ... d.at(0) | tst.ts:402:24:402:40 | [MethodCallExpr] palette.red.at(0) | semmle.order | 2 | -| tst.ts:402:24:402:34 | [DotExpr] palette.red | tst.ts:402:24:402:30 | [VarRef] palette | semmle.label | 1 | -| tst.ts:402:24:402:34 | [DotExpr] palette.red | tst.ts:402:24:402:30 | [VarRef] palette | semmle.order | 1 | -| tst.ts:402:24:402:34 | [DotExpr] palette.red | tst.ts:402:32:402:34 | [Label] red | semmle.label | 2 | -| tst.ts:402:24:402:34 | [DotExpr] palette.red | tst.ts:402:32:402:34 | [Label] red | semmle.order | 2 | -| tst.ts:402:24:402:37 | [DotExpr] palette.red.at | tst.ts:402:24:402:34 | [DotExpr] palette.red | semmle.label | 1 | -| tst.ts:402:24:402:37 | [DotExpr] palette.red.at | tst.ts:402:24:402:34 | [DotExpr] palette.red | semmle.order | 1 | -| tst.ts:402:24:402:37 | [DotExpr] palette.red.at | tst.ts:402:36:402:37 | [Label] at | semmle.label | 2 | -| tst.ts:402:24:402:37 | [DotExpr] palette.red.at | tst.ts:402:36:402:37 | [Label] at | semmle.order | 2 | -| tst.ts:402:24:402:40 | [MethodCallExpr] palette.red.at(0) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:402:24:402:40 | [MethodCallExpr] palette.red.at(0) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:402:24:402:40 | [MethodCallExpr] palette.red.at(0) | tst.ts:402:24:402:37 | [DotExpr] palette.red.at | semmle.label | 0 | -| tst.ts:402:24:402:40 | [MethodCallExpr] palette.red.at(0) | tst.ts:402:24:402:37 | [DotExpr] palette.red.at | semmle.order | 0 | -| tst.ts:404:3:406:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | tst.ts:404:13:404:18 | [Identifier] RGBObj | semmle.label | 1 | -| tst.ts:404:3:406:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | tst.ts:404:13:404:18 | [Identifier] RGBObj | semmle.order | 1 | -| tst.ts:404:3:406:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | tst.ts:405:5:405:16 | [FieldDeclaration] red: number; | semmle.label | 2 | -| tst.ts:404:3:406:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | tst.ts:405:5:405:16 | [FieldDeclaration] red: number; | semmle.order | 2 | -| tst.ts:405:5:405:16 | [FieldDeclaration] red: number; | tst.ts:405:5:405:7 | [Label] red | semmle.label | 1 | -| tst.ts:405:5:405:16 | [FieldDeclaration] red: number; | tst.ts:405:5:405:7 | [Label] red | semmle.order | 1 | -| tst.ts:405:5:405:16 | [FieldDeclaration] red: number; | tst.ts:405:10:405:15 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:405:5:405:16 | [FieldDeclaration] red: number; | tst.ts:405:10:405:15 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:408:3:410:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | tst.ts:408:13:408:18 | [Identifier] HSVObj | semmle.label | 1 | -| tst.ts:408:3:410:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | tst.ts:408:13:408:18 | [Identifier] HSVObj | semmle.order | 1 | -| tst.ts:408:3:410:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | tst.ts:409:5:409:16 | [FieldDeclaration] hue: number; | semmle.label | 2 | -| tst.ts:408:3:410:3 | [InterfaceDeclaration,TypeDefinition] interfa ... er; } | tst.ts:409:5:409:16 | [FieldDeclaration] hue: number; | semmle.order | 2 | -| tst.ts:409:5:409:16 | [FieldDeclaration] hue: number; | tst.ts:409:5:409:7 | [Label] hue | semmle.label | 1 | -| tst.ts:409:5:409:16 | [FieldDeclaration] hue: number; | tst.ts:409:5:409:7 | [Label] hue | semmle.order | 1 | -| tst.ts:409:5:409:16 | [FieldDeclaration] hue: number; | tst.ts:409:10:409:15 | [KeywordTypeExpr] number | semmle.label | 2 | -| tst.ts:409:5:409:16 | [FieldDeclaration] hue: number; | tst.ts:409:10:409:15 | [KeywordTypeExpr] number | semmle.order | 2 | -| tst.ts:412:3:416:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:412:3:416:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:412:3:416:3 | [FunctionDeclStmt] functio ... } } | tst.ts:412:12:412:19 | [VarDecl] setColor | semmle.label | 0 | -| tst.ts:412:3:416:3 | [FunctionDeclStmt] functio ... } } | tst.ts:412:12:412:19 | [VarDecl] setColor | semmle.order | 0 | -| tst.ts:412:3:416:3 | [FunctionDeclStmt] functio ... } } | tst.ts:412:45:416:3 | [BlockStmt] { i ... } } | semmle.label | 5 | -| tst.ts:412:3:416:3 | [FunctionDeclStmt] functio ... } } | tst.ts:412:45:416:3 | [BlockStmt] { i ... } } | semmle.order | 5 | -| tst.ts:412:21:412:25 | [SimpleParameter] color | tst.ts:412:28:412:42 | [UnionTypeExpr] RGBObj \| HSVObj | semmle.label | -2 | -| tst.ts:412:21:412:25 | [SimpleParameter] color | tst.ts:412:28:412:42 | [UnionTypeExpr] RGBObj \| HSVObj | semmle.order | -2 | -| tst.ts:412:28:412:42 | [UnionTypeExpr] RGBObj \| HSVObj | tst.ts:412:28:412:33 | [LocalTypeAccess] RGBObj | semmle.label | 1 | -| tst.ts:412:28:412:42 | [UnionTypeExpr] RGBObj \| HSVObj | tst.ts:412:28:412:33 | [LocalTypeAccess] RGBObj | semmle.order | 1 | -| tst.ts:412:28:412:42 | [UnionTypeExpr] RGBObj \| HSVObj | tst.ts:412:37:412:42 | [LocalTypeAccess] HSVObj | semmle.label | 2 | -| tst.ts:412:28:412:42 | [UnionTypeExpr] RGBObj \| HSVObj | tst.ts:412:37:412:42 | [LocalTypeAccess] HSVObj | semmle.order | 2 | -| tst.ts:412:45:416:3 | [BlockStmt] { i ... } } | tst.ts:413:5:415:5 | [IfStmt] if ("hu ... j } | semmle.label | 1 | -| tst.ts:412:45:416:3 | [BlockStmt] { i ... } } | tst.ts:413:5:415:5 | [IfStmt] if ("hu ... j } | semmle.order | 1 | -| tst.ts:413:5:415:5 | [IfStmt] if ("hu ... j } | tst.ts:413:9:413:22 | [BinaryExpr] "hue" in color | semmle.label | 1 | -| tst.ts:413:5:415:5 | [IfStmt] if ("hu ... j } | tst.ts:413:9:413:22 | [BinaryExpr] "hue" in color | semmle.order | 1 | -| tst.ts:413:5:415:5 | [IfStmt] if ("hu ... j } | tst.ts:413:25:415:5 | [BlockStmt] { ... j } | semmle.label | 2 | -| tst.ts:413:5:415:5 | [IfStmt] if ("hu ... j } | tst.ts:413:25:415:5 | [BlockStmt] { ... j } | semmle.order | 2 | -| tst.ts:413:9:413:22 | [BinaryExpr] "hue" in color | tst.ts:413:9:413:13 | [Literal] "hue" | semmle.label | 1 | -| tst.ts:413:9:413:22 | [BinaryExpr] "hue" in color | tst.ts:413:9:413:13 | [Literal] "hue" | semmle.order | 1 | -| tst.ts:413:9:413:22 | [BinaryExpr] "hue" in color | tst.ts:413:18:413:22 | [VarRef] color | semmle.label | 2 | -| tst.ts:413:9:413:22 | [BinaryExpr] "hue" in color | tst.ts:413:18:413:22 | [VarRef] color | semmle.order | 2 | -| tst.ts:413:25:415:5 | [BlockStmt] { ... j } | tst.ts:414:7:414:20 | [DeclStmt] let h = ... | semmle.label | 1 | -| tst.ts:413:25:415:5 | [BlockStmt] { ... j } | tst.ts:414:7:414:20 | [DeclStmt] let h = ... | semmle.order | 1 | -| tst.ts:414:7:414:20 | [DeclStmt] let h = ... | tst.ts:414:11:414:19 | [VariableDeclarator] h = color | semmle.label | 1 | -| tst.ts:414:7:414:20 | [DeclStmt] let h = ... | tst.ts:414:11:414:19 | [VariableDeclarator] h = color | semmle.order | 1 | -| tst.ts:414:11:414:19 | [VariableDeclarator] h = color | tst.ts:414:11:414:11 | [VarDecl] h | semmle.label | 1 | -| tst.ts:414:11:414:19 | [VariableDeclarator] h = color | tst.ts:414:11:414:11 | [VarDecl] h | semmle.order | 1 | -| tst.ts:414:11:414:19 | [VariableDeclarator] h = color | tst.ts:414:15:414:19 | [VarRef] color | semmle.label | 2 | -| tst.ts:414:11:414:19 | [VariableDeclarator] h = color | tst.ts:414:15:414:19 | [VarRef] color | semmle.order | 2 | -| tst.ts:419:3:425:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:419:9:419:14 | [VarDecl] Person | semmle.label | 1 | -| tst.ts:419:3:425:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:419:9:419:14 | [VarDecl] Person | semmle.order | 1 | -| tst.ts:419:3:425:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:420:5:420:26 | [FieldDeclaration] accesso ... string; | semmle.label | 2 | -| tst.ts:419:3:425:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:420:5:420:26 | [FieldDeclaration] accesso ... string; | semmle.order | 2 | -| tst.ts:419:3:425:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:422:5:424:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | semmle.label | 3 | -| tst.ts:419:3:425:3 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:422:5:424:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | semmle.order | 3 | -| tst.ts:420:5:420:26 | [FieldDeclaration] accesso ... string; | tst.ts:420:14:420:17 | [Label] name | semmle.label | 1 | -| tst.ts:420:5:420:26 | [FieldDeclaration] accesso ... string; | tst.ts:420:14:420:17 | [Label] name | semmle.order | 1 | -| tst.ts:420:5:420:26 | [FieldDeclaration] accesso ... string; | tst.ts:420:20:420:25 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:420:5:420:26 | [FieldDeclaration] accesso ... string; | tst.ts:420:20:420:25 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:422:5:424:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:422:5:424:5 | [FunctionExpr] constru ... ; } | semmle.label | 2 | -| tst.ts:422:5:424:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:422:5:424:5 | [FunctionExpr] constru ... ; } | semmle.order | 2 | -| tst.ts:422:5:424:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:422:5:424:5 | [Label] constructor | semmle.label | 1 | -| tst.ts:422:5:424:5 | [ClassInitializedMember,ConstructorDefinition] constru ... ; } | tst.ts:422:5:424:5 | [Label] constructor | semmle.order | 1 | -| tst.ts:422:5:424:5 | [FunctionExpr] constru ... ; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:422:5:424:5 | [FunctionExpr] constru ... ; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:422:5:424:5 | [FunctionExpr] constru ... ; } | tst.ts:422:31:424:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:422:5:424:5 | [FunctionExpr] constru ... ; } | tst.ts:422:31:424:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:422:17:422:20 | [SimpleParameter] name | tst.ts:422:23:422:28 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:422:17:422:20 | [SimpleParameter] name | tst.ts:422:23:422:28 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:422:31:424:5 | [BlockStmt] { ... ; } | tst.ts:423:7:423:23 | [ExprStmt] this.name = name; | semmle.label | 1 | -| tst.ts:422:31:424:5 | [BlockStmt] { ... ; } | tst.ts:423:7:423:23 | [ExprStmt] this.name = name; | semmle.order | 1 | -| tst.ts:423:7:423:15 | [DotExpr] this.name | tst.ts:423:7:423:10 | [ThisExpr] this | semmle.label | 1 | -| tst.ts:423:7:423:15 | [DotExpr] this.name | tst.ts:423:7:423:10 | [ThisExpr] this | semmle.order | 1 | -| tst.ts:423:7:423:15 | [DotExpr] this.name | tst.ts:423:12:423:15 | [Label] name | semmle.label | 2 | -| tst.ts:423:7:423:15 | [DotExpr] this.name | tst.ts:423:12:423:15 | [Label] name | semmle.order | 2 | -| tst.ts:423:7:423:22 | [AssignExpr] this.name = name | tst.ts:423:7:423:15 | [DotExpr] this.name | semmle.label | 1 | -| tst.ts:423:7:423:22 | [AssignExpr] this.name = name | tst.ts:423:7:423:15 | [DotExpr] this.name | semmle.order | 1 | -| tst.ts:423:7:423:22 | [AssignExpr] this.name = name | tst.ts:423:19:423:22 | [VarRef] name | semmle.label | 2 | -| tst.ts:423:7:423:22 | [AssignExpr] this.name = name | tst.ts:423:19:423:22 | [VarRef] name | semmle.order | 2 | -| tst.ts:423:7:423:23 | [ExprStmt] this.name = name; | tst.ts:423:7:423:22 | [AssignExpr] this.name = name | semmle.label | 1 | -| tst.ts:423:7:423:23 | [ExprStmt] this.name = name; | tst.ts:423:7:423:22 | [AssignExpr] this.name = name | semmle.order | 1 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:430:8:430:11 | [VarDecl] TS50 | semmle.label | 1 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:430:8:430:11 | [VarDecl] TS50 | semmle.order | 1 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | semmle.label | 2 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | semmle.order | 2 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | semmle.label | 3 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | semmle.order | 3 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:460:5:460:41 | [DeclStmt] const p = ... | semmle.label | 4 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:460:5:460:41 | [DeclStmt] const p = ... | semmle.order | 4 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | semmle.label | 5 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | semmle.order | 5 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:465:5:465:51 | [DeclStmt] const foo = ... | semmle.label | 6 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:465:5:465:51 | [DeclStmt] const foo = ... | semmle.order | 6 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:467:5:467:21 | [DeclStmt] const b = ... | semmle.label | 7 | -| tst.ts:430:1:468:1 | [NamespaceDeclaration] module ... - "b" } | tst.ts:467:5:467:21 | [DeclStmt] const b = ... | semmle.order | 7 | -| tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | file://:0:0:0:0 | (TypeParameters) | semmle.label | 2 | -| tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | file://:0:0:0:0 | (TypeParameters) | semmle.order | 2 | -| tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | tst.ts:431:14:431:25 | [VarDecl] loggedMethod | semmle.label | 0 | -| tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | tst.ts:431:14:431:25 | [VarDecl] loggedMethod | semmle.order | 0 | -| tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | tst.ts:434:7:445:5 | [BlockStmt] { ... ; } | semmle.label | 5 | -| tst.ts:431:5:445:5 | [FunctionDeclStmt] functio ... ; } | tst.ts:434:7:445:5 | [BlockStmt] { ... ; } | semmle.order | 5 | -| tst.ts:431:27:431:30 | [TypeParameter] This | tst.ts:431:27:431:30 | [Identifier] This | semmle.label | 1 | -| tst.ts:431:27:431:30 | [TypeParameter] This | tst.ts:431:27:431:30 | [Identifier] This | semmle.order | 1 | -| tst.ts:431:33:431:50 | [TypeParameter] Args extends any[] | tst.ts:431:33:431:36 | [Identifier] Args | semmle.label | 1 | -| tst.ts:431:33:431:50 | [TypeParameter] Args extends any[] | tst.ts:431:33:431:36 | [Identifier] Args | semmle.order | 1 | -| tst.ts:431:33:431:50 | [TypeParameter] Args extends any[] | tst.ts:431:46:431:50 | [ArrayTypeExpr] any[] | semmle.label | 2 | -| tst.ts:431:33:431:50 | [TypeParameter] Args extends any[] | tst.ts:431:46:431:50 | [ArrayTypeExpr] any[] | semmle.order | 2 | -| tst.ts:431:46:431:50 | [ArrayTypeExpr] any[] | tst.ts:431:46:431:48 | [KeywordTypeExpr] any | semmle.label | 1 | -| tst.ts:431:46:431:50 | [ArrayTypeExpr] any[] | tst.ts:431:46:431:48 | [KeywordTypeExpr] any | semmle.order | 1 | -| tst.ts:431:53:431:58 | [TypeParameter] Return | tst.ts:431:53:431:58 | [Identifier] Return | semmle.label | 1 | -| tst.ts:431:53:431:58 | [TypeParameter] Return | tst.ts:431:53:431:58 | [Identifier] Return | semmle.order | 1 | -| tst.ts:432:9:432:14 | [SimpleParameter] target | tst.ts:432:17:432:53 | [FunctionTypeExpr] (this: ... Return | semmle.label | -2 | -| tst.ts:432:9:432:14 | [SimpleParameter] target | tst.ts:432:17:432:53 | [FunctionTypeExpr] (this: ... Return | semmle.order | -2 | -| tst.ts:432:17:432:53 | [FunctionExpr] (this: ... Return | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:432:17:432:53 | [FunctionExpr] (this: ... Return | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:432:17:432:53 | [FunctionExpr] (this: ... Return | tst.ts:432:24:432:27 | [LocalTypeAccess] This | semmle.label | 3 | -| tst.ts:432:17:432:53 | [FunctionExpr] (this: ... Return | tst.ts:432:24:432:27 | [LocalTypeAccess] This | semmle.order | 3 | -| tst.ts:432:17:432:53 | [FunctionExpr] (this: ... Return | tst.ts:432:48:432:53 | [LocalTypeAccess] Return | semmle.label | 4 | -| tst.ts:432:17:432:53 | [FunctionExpr] (this: ... Return | tst.ts:432:48:432:53 | [LocalTypeAccess] Return | semmle.order | 4 | -| tst.ts:432:17:432:53 | [FunctionTypeExpr] (this: ... Return | tst.ts:432:17:432:53 | [FunctionExpr] (this: ... Return | semmle.label | 1 | -| tst.ts:432:17:432:53 | [FunctionTypeExpr] (this: ... Return | tst.ts:432:17:432:53 | [FunctionExpr] (this: ... Return | semmle.order | 1 | -| tst.ts:432:33:432:36 | [SimpleParameter] args | tst.ts:432:39:432:42 | [LocalTypeAccess] Args | semmle.label | -2 | -| tst.ts:432:33:432:36 | [SimpleParameter] args | tst.ts:432:39:432:42 | [LocalTypeAccess] Args | semmle.order | -2 | -| tst.ts:433:9:433:15 | [SimpleParameter] context | tst.ts:433:18:433:89 | [GenericTypeExpr] ClassMe ... Return> | semmle.label | -2 | -| tst.ts:433:9:433:15 | [SimpleParameter] context | tst.ts:433:18:433:89 | [GenericTypeExpr] ClassMe ... Return> | semmle.order | -2 | -| tst.ts:433:18:433:89 | [GenericTypeExpr] ClassMe ... Return> | tst.ts:433:18:433:44 | [LocalTypeAccess] ClassMethodDecoratorContext | semmle.label | 1 | -| tst.ts:433:18:433:89 | [GenericTypeExpr] ClassMe ... Return> | tst.ts:433:18:433:44 | [LocalTypeAccess] ClassMethodDecoratorContext | semmle.order | 1 | -| tst.ts:433:18:433:89 | [GenericTypeExpr] ClassMe ... Return> | tst.ts:433:46:433:49 | [LocalTypeAccess] This | semmle.label | 2 | -| tst.ts:433:18:433:89 | [GenericTypeExpr] ClassMe ... Return> | tst.ts:433:46:433:49 | [LocalTypeAccess] This | semmle.order | 2 | -| tst.ts:433:18:433:89 | [GenericTypeExpr] ClassMe ... Return> | tst.ts:433:52:433:88 | [FunctionTypeExpr] (this: ... Return | semmle.label | 3 | -| tst.ts:433:18:433:89 | [GenericTypeExpr] ClassMe ... Return> | tst.ts:433:52:433:88 | [FunctionTypeExpr] (this: ... Return | semmle.order | 3 | -| tst.ts:433:52:433:88 | [FunctionExpr] (this: ... Return | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:433:52:433:88 | [FunctionExpr] (this: ... Return | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:433:52:433:88 | [FunctionExpr] (this: ... Return | tst.ts:433:59:433:62 | [LocalTypeAccess] This | semmle.label | 3 | -| tst.ts:433:52:433:88 | [FunctionExpr] (this: ... Return | tst.ts:433:59:433:62 | [LocalTypeAccess] This | semmle.order | 3 | -| tst.ts:433:52:433:88 | [FunctionExpr] (this: ... Return | tst.ts:433:83:433:88 | [LocalTypeAccess] Return | semmle.label | 4 | -| tst.ts:433:52:433:88 | [FunctionExpr] (this: ... Return | tst.ts:433:83:433:88 | [LocalTypeAccess] Return | semmle.order | 4 | -| tst.ts:433:52:433:88 | [FunctionTypeExpr] (this: ... Return | tst.ts:433:52:433:88 | [FunctionExpr] (this: ... Return | semmle.label | 1 | -| tst.ts:433:52:433:88 | [FunctionTypeExpr] (this: ... Return | tst.ts:433:52:433:88 | [FunctionExpr] (this: ... Return | semmle.order | 1 | -| tst.ts:433:68:433:71 | [SimpleParameter] args | tst.ts:433:74:433:77 | [LocalTypeAccess] Args | semmle.label | -2 | -| tst.ts:433:68:433:71 | [SimpleParameter] args | tst.ts:433:74:433:77 | [LocalTypeAccess] Args | semmle.order | -2 | -| tst.ts:434:7:445:5 | [BlockStmt] { ... ; } | tst.ts:435:9:435:48 | [DeclStmt] const methodName = ... | semmle.label | 1 | -| tst.ts:434:7:445:5 | [BlockStmt] { ... ; } | tst.ts:435:9:435:48 | [DeclStmt] const methodName = ... | semmle.order | 1 | -| tst.ts:434:7:445:5 | [BlockStmt] { ... ; } | tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | semmle.label | 2 | -| tst.ts:434:7:445:5 | [BlockStmt] { ... ; } | tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | semmle.order | 2 | -| tst.ts:434:7:445:5 | [BlockStmt] { ... ; } | tst.ts:444:9:444:33 | [ReturnStmt] return ... Method; | semmle.label | 3 | -| tst.ts:434:7:445:5 | [BlockStmt] { ... ; } | tst.ts:444:9:444:33 | [ReturnStmt] return ... Method; | semmle.order | 3 | -| tst.ts:435:9:435:48 | [DeclStmt] const methodName = ... | tst.ts:435:15:435:47 | [VariableDeclarator] methodN ... t.name) | semmle.label | 1 | -| tst.ts:435:9:435:48 | [DeclStmt] const methodName = ... | tst.ts:435:15:435:47 | [VariableDeclarator] methodN ... t.name) | semmle.order | 1 | -| tst.ts:435:15:435:47 | [VariableDeclarator] methodN ... t.name) | tst.ts:435:15:435:24 | [VarDecl] methodName | semmle.label | 1 | -| tst.ts:435:15:435:47 | [VariableDeclarator] methodN ... t.name) | tst.ts:435:15:435:24 | [VarDecl] methodName | semmle.order | 1 | -| tst.ts:435:15:435:47 | [VariableDeclarator] methodN ... t.name) | tst.ts:435:28:435:47 | [CallExpr] String(context.name) | semmle.label | 2 | -| tst.ts:435:15:435:47 | [VariableDeclarator] methodN ... t.name) | tst.ts:435:28:435:47 | [CallExpr] String(context.name) | semmle.order | 2 | -| tst.ts:435:28:435:47 | [CallExpr] String(context.name) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:435:28:435:47 | [CallExpr] String(context.name) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:435:28:435:47 | [CallExpr] String(context.name) | tst.ts:435:28:435:33 | [VarRef] String | semmle.label | 0 | -| tst.ts:435:28:435:47 | [CallExpr] String(context.name) | tst.ts:435:28:435:33 | [VarRef] String | semmle.order | 0 | -| tst.ts:435:35:435:46 | [DotExpr] context.name | tst.ts:435:35:435:41 | [VarRef] context | semmle.label | 1 | -| tst.ts:435:35:435:46 | [DotExpr] context.name | tst.ts:435:35:435:41 | [VarRef] context | semmle.order | 1 | -| tst.ts:435:35:435:46 | [DotExpr] context.name | tst.ts:435:43:435:46 | [Label] name | semmle.label | 2 | -| tst.ts:435:35:435:46 | [DotExpr] context.name | tst.ts:435:43:435:46 | [Label] name | semmle.order | 2 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | tst.ts:437:18:437:34 | [VarDecl] replacementMethod | semmle.label | 0 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | tst.ts:437:18:437:34 | [VarDecl] replacementMethod | semmle.order | 0 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | tst.ts:437:42:437:45 | [LocalTypeAccess] This | semmle.label | 3 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | tst.ts:437:42:437:45 | [LocalTypeAccess] This | semmle.order | 3 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | tst.ts:437:64:437:69 | [LocalTypeAccess] Return | semmle.label | 4 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | tst.ts:437:64:437:69 | [LocalTypeAccess] Return | semmle.order | 4 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | tst.ts:437:71:442:9 | [BlockStmt] { ... } | semmle.label | 5 | -| tst.ts:437:9:442:9 | [FunctionDeclStmt] functio ... } | tst.ts:437:71:442:9 | [BlockStmt] { ... } | semmle.order | 5 | -| tst.ts:437:51:437:54 | [SimpleParameter] args | tst.ts:437:57:437:60 | [LocalTypeAccess] Args | semmle.label | -2 | -| tst.ts:437:51:437:54 | [SimpleParameter] args | tst.ts:437:57:437:60 | [LocalTypeAccess] Args | semmle.order | -2 | -| tst.ts:437:71:442:9 | [BlockStmt] { ... } | tst.ts:438:13:438:64 | [ExprStmt] console ... me}'.`) | semmle.label | 1 | -| tst.ts:437:71:442:9 | [BlockStmt] { ... } | tst.ts:438:13:438:64 | [ExprStmt] console ... me}'.`) | semmle.order | 1 | -| tst.ts:437:71:442:9 | [BlockStmt] { ... } | tst.ts:439:13:439:54 | [DeclStmt] const result = ... | semmle.label | 2 | -| tst.ts:437:71:442:9 | [BlockStmt] { ... } | tst.ts:439:13:439:54 | [DeclStmt] const result = ... | semmle.order | 2 | -| tst.ts:437:71:442:9 | [BlockStmt] { ... } | tst.ts:440:13:440:63 | [ExprStmt] console ... me}'.`) | semmle.label | 3 | -| tst.ts:437:71:442:9 | [BlockStmt] { ... } | tst.ts:440:13:440:63 | [ExprStmt] console ... me}'.`) | semmle.order | 3 | -| tst.ts:437:71:442:9 | [BlockStmt] { ... } | tst.ts:441:13:441:26 | [ReturnStmt] return result; | semmle.label | 4 | -| tst.ts:437:71:442:9 | [BlockStmt] { ... } | tst.ts:441:13:441:26 | [ReturnStmt] return result; | semmle.order | 4 | -| tst.ts:438:13:438:23 | [DotExpr] console.log | tst.ts:438:13:438:19 | [VarRef] console | semmle.label | 1 | -| tst.ts:438:13:438:23 | [DotExpr] console.log | tst.ts:438:13:438:19 | [VarRef] console | semmle.order | 1 | -| tst.ts:438:13:438:23 | [DotExpr] console.log | tst.ts:438:21:438:23 | [Label] log | semmle.label | 2 | -| tst.ts:438:13:438:23 | [DotExpr] console.log | tst.ts:438:21:438:23 | [Label] log | semmle.order | 2 | -| tst.ts:438:13:438:64 | [ExprStmt] console ... me}'.`) | tst.ts:438:13:438:64 | [MethodCallExpr] console ... me}'.`) | semmle.label | 1 | -| tst.ts:438:13:438:64 | [ExprStmt] console ... me}'.`) | tst.ts:438:13:438:64 | [MethodCallExpr] console ... me}'.`) | semmle.order | 1 | -| tst.ts:438:13:438:64 | [MethodCallExpr] console ... me}'.`) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:438:13:438:64 | [MethodCallExpr] console ... me}'.`) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:438:13:438:64 | [MethodCallExpr] console ... me}'.`) | tst.ts:438:13:438:23 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:438:13:438:64 | [MethodCallExpr] console ... me}'.`) | tst.ts:438:13:438:23 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:438:25:438:63 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:438:26:438:47 | [TemplateElement] LOG: En ... ethod ' | semmle.label | 1 | -| tst.ts:438:25:438:63 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:438:26:438:47 | [TemplateElement] LOG: En ... ethod ' | semmle.order | 1 | -| tst.ts:438:25:438:63 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:438:50:438:59 | [VarRef] methodName | semmle.label | 2 | -| tst.ts:438:25:438:63 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:438:50:438:59 | [VarRef] methodName | semmle.order | 2 | -| tst.ts:438:25:438:63 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:438:61:438:62 | [TemplateElement] '. | semmle.label | 3 | -| tst.ts:438:25:438:63 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:438:61:438:62 | [TemplateElement] '. | semmle.order | 3 | -| tst.ts:439:13:439:54 | [DeclStmt] const result = ... | tst.ts:439:19:439:53 | [VariableDeclarator] result ... ..args) | semmle.label | 1 | -| tst.ts:439:13:439:54 | [DeclStmt] const result = ... | tst.ts:439:19:439:53 | [VariableDeclarator] result ... ..args) | semmle.order | 1 | -| tst.ts:439:19:439:53 | [VariableDeclarator] result ... ..args) | tst.ts:439:19:439:24 | [VarDecl] result | semmle.label | 1 | -| tst.ts:439:19:439:53 | [VariableDeclarator] result ... ..args) | tst.ts:439:19:439:24 | [VarDecl] result | semmle.order | 1 | -| tst.ts:439:19:439:53 | [VariableDeclarator] result ... ..args) | tst.ts:439:28:439:53 | [MethodCallExpr] target. ... ..args) | semmle.label | 2 | -| tst.ts:439:19:439:53 | [VariableDeclarator] result ... ..args) | tst.ts:439:28:439:53 | [MethodCallExpr] target. ... ..args) | semmle.order | 2 | -| tst.ts:439:28:439:38 | [DotExpr] target.call | tst.ts:439:28:439:33 | [VarRef] target | semmle.label | 1 | -| tst.ts:439:28:439:38 | [DotExpr] target.call | tst.ts:439:28:439:33 | [VarRef] target | semmle.order | 1 | -| tst.ts:439:28:439:38 | [DotExpr] target.call | tst.ts:439:35:439:38 | [Label] call | semmle.label | 2 | -| tst.ts:439:28:439:38 | [DotExpr] target.call | tst.ts:439:35:439:38 | [Label] call | semmle.order | 2 | -| tst.ts:439:28:439:53 | [MethodCallExpr] target. ... ..args) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:439:28:439:53 | [MethodCallExpr] target. ... ..args) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:439:28:439:53 | [MethodCallExpr] target. ... ..args) | tst.ts:439:28:439:38 | [DotExpr] target.call | semmle.label | 0 | -| tst.ts:439:28:439:53 | [MethodCallExpr] target. ... ..args) | tst.ts:439:28:439:38 | [DotExpr] target.call | semmle.order | 0 | -| tst.ts:439:46:439:52 | [SpreadElement] ...args | tst.ts:439:49:439:52 | [VarRef] args | semmle.label | 1 | -| tst.ts:439:46:439:52 | [SpreadElement] ...args | tst.ts:439:49:439:52 | [VarRef] args | semmle.order | 1 | -| tst.ts:440:13:440:23 | [DotExpr] console.log | tst.ts:440:13:440:19 | [VarRef] console | semmle.label | 1 | -| tst.ts:440:13:440:23 | [DotExpr] console.log | tst.ts:440:13:440:19 | [VarRef] console | semmle.order | 1 | -| tst.ts:440:13:440:23 | [DotExpr] console.log | tst.ts:440:21:440:23 | [Label] log | semmle.label | 2 | -| tst.ts:440:13:440:23 | [DotExpr] console.log | tst.ts:440:21:440:23 | [Label] log | semmle.order | 2 | -| tst.ts:440:13:440:63 | [ExprStmt] console ... me}'.`) | tst.ts:440:13:440:63 | [MethodCallExpr] console ... me}'.`) | semmle.label | 1 | -| tst.ts:440:13:440:63 | [ExprStmt] console ... me}'.`) | tst.ts:440:13:440:63 | [MethodCallExpr] console ... me}'.`) | semmle.order | 1 | -| tst.ts:440:13:440:63 | [MethodCallExpr] console ... me}'.`) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:440:13:440:63 | [MethodCallExpr] console ... me}'.`) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:440:13:440:63 | [MethodCallExpr] console ... me}'.`) | tst.ts:440:13:440:23 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:440:13:440:63 | [MethodCallExpr] console ... me}'.`) | tst.ts:440:13:440:23 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:440:25:440:62 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:440:26:440:46 | [TemplateElement] LOG: Ex ... ethod ' | semmle.label | 1 | -| tst.ts:440:25:440:62 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:440:26:440:46 | [TemplateElement] LOG: Ex ... ethod ' | semmle.order | 1 | -| tst.ts:440:25:440:62 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:440:49:440:58 | [VarRef] methodName | semmle.label | 2 | -| tst.ts:440:25:440:62 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:440:49:440:58 | [VarRef] methodName | semmle.order | 2 | -| tst.ts:440:25:440:62 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:440:60:440:61 | [TemplateElement] '. | semmle.label | 3 | -| tst.ts:440:25:440:62 | [TemplateLiteral] `LOG: E ... ame}'.` | tst.ts:440:60:440:61 | [TemplateElement] '. | semmle.order | 3 | -| tst.ts:441:13:441:26 | [ReturnStmt] return result; | tst.ts:441:20:441:25 | [VarRef] result | semmle.label | 1 | -| tst.ts:441:13:441:26 | [ReturnStmt] return result; | tst.ts:441:20:441:25 | [VarRef] result | semmle.order | 1 | -| tst.ts:444:9:444:33 | [ReturnStmt] return ... Method; | tst.ts:444:16:444:32 | [VarRef] replacementMethod | semmle.label | 1 | -| tst.ts:444:9:444:33 | [ReturnStmt] return ... Method; | tst.ts:444:16:444:32 | [VarRef] replacementMethod | semmle.order | 1 | -| tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:447:11:447:16 | [VarDecl] Person | semmle.label | 1 | -| tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:447:11:447:16 | [VarDecl] Person | semmle.order | 1 | -| tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:448:9:448:21 | [FieldDeclaration] name: string; | semmle.label | 2 | -| tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:448:9:448:21 | [FieldDeclaration] name: string; | semmle.order | 2 | -| tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:449:9:451:9 | [ClassInitializedMember,ConstructorDefinition] constru ... } | semmle.label | 3 | -| tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:449:9:451:9 | [ClassInitializedMember,ConstructorDefinition] constru ... } | semmle.order | 3 | -| tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:454:9:457:9 | [ClassInitializedMember,MethodDefinition] greet() ... } | semmle.label | 4 | -| tst.ts:447:5:458:5 | [ClassDefinition,TypeDefinition] class P ... } } | tst.ts:454:9:457:9 | [ClassInitializedMember,MethodDefinition] greet() ... } | semmle.order | 4 | -| tst.ts:448:9:448:21 | [FieldDeclaration] name: string; | tst.ts:448:9:448:12 | [Label] name | semmle.label | 1 | -| tst.ts:448:9:448:21 | [FieldDeclaration] name: string; | tst.ts:448:9:448:12 | [Label] name | semmle.order | 1 | -| tst.ts:448:9:448:21 | [FieldDeclaration] name: string; | tst.ts:448:15:448:20 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:448:9:448:21 | [FieldDeclaration] name: string; | tst.ts:448:15:448:20 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:449:9:451:9 | [ClassInitializedMember,ConstructorDefinition] constru ... } | tst.ts:449:9:451:9 | [FunctionExpr] constru ... } | semmle.label | 2 | -| tst.ts:449:9:451:9 | [ClassInitializedMember,ConstructorDefinition] constru ... } | tst.ts:449:9:451:9 | [FunctionExpr] constru ... } | semmle.order | 2 | -| tst.ts:449:9:451:9 | [ClassInitializedMember,ConstructorDefinition] constru ... } | tst.ts:449:9:451:9 | [Label] constructor | semmle.label | 1 | -| tst.ts:449:9:451:9 | [ClassInitializedMember,ConstructorDefinition] constru ... } | tst.ts:449:9:451:9 | [Label] constructor | semmle.order | 1 | -| tst.ts:449:9:451:9 | [FunctionExpr] constru ... } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:449:9:451:9 | [FunctionExpr] constru ... } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:449:9:451:9 | [FunctionExpr] constru ... } | tst.ts:449:35:451:9 | [BlockStmt] { ... } | semmle.label | 5 | -| tst.ts:449:9:451:9 | [FunctionExpr] constru ... } | tst.ts:449:35:451:9 | [BlockStmt] { ... } | semmle.order | 5 | -| tst.ts:449:21:449:24 | [SimpleParameter] name | tst.ts:449:27:449:32 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:449:21:449:24 | [SimpleParameter] name | tst.ts:449:27:449:32 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:449:35:451:9 | [BlockStmt] { ... } | tst.ts:450:13:450:29 | [ExprStmt] this.name = name; | semmle.label | 1 | -| tst.ts:449:35:451:9 | [BlockStmt] { ... } | tst.ts:450:13:450:29 | [ExprStmt] this.name = name; | semmle.order | 1 | -| tst.ts:450:13:450:21 | [DotExpr] this.name | tst.ts:450:13:450:16 | [ThisExpr] this | semmle.label | 1 | -| tst.ts:450:13:450:21 | [DotExpr] this.name | tst.ts:450:13:450:16 | [ThisExpr] this | semmle.order | 1 | -| tst.ts:450:13:450:21 | [DotExpr] this.name | tst.ts:450:18:450:21 | [Label] name | semmle.label | 2 | -| tst.ts:450:13:450:21 | [DotExpr] this.name | tst.ts:450:18:450:21 | [Label] name | semmle.order | 2 | -| tst.ts:450:13:450:28 | [AssignExpr] this.name = name | tst.ts:450:13:450:21 | [DotExpr] this.name | semmle.label | 1 | -| tst.ts:450:13:450:28 | [AssignExpr] this.name = name | tst.ts:450:13:450:21 | [DotExpr] this.name | semmle.order | 1 | -| tst.ts:450:13:450:28 | [AssignExpr] this.name = name | tst.ts:450:25:450:28 | [VarRef] name | semmle.label | 2 | -| tst.ts:450:13:450:28 | [AssignExpr] this.name = name | tst.ts:450:25:450:28 | [VarRef] name | semmle.order | 2 | -| tst.ts:450:13:450:29 | [ExprStmt] this.name = name; | tst.ts:450:13:450:28 | [AssignExpr] this.name = name | semmle.label | 1 | -| tst.ts:450:13:450:29 | [ExprStmt] this.name = name; | tst.ts:450:13:450:28 | [AssignExpr] this.name = name | semmle.order | 1 | -| tst.ts:453:9:453:25 | [Decorator] @loggedMethod("") | tst.ts:453:10:453:25 | [CallExpr] loggedMethod("") | semmle.label | 1 | -| tst.ts:453:9:453:25 | [Decorator] @loggedMethod("") | tst.ts:453:10:453:25 | [CallExpr] loggedMethod("") | semmle.order | 1 | -| tst.ts:453:10:453:25 | [CallExpr] loggedMethod("") | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:453:10:453:25 | [CallExpr] loggedMethod("") | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:453:10:453:25 | [CallExpr] loggedMethod("") | tst.ts:453:10:453:21 | [VarRef] loggedMethod | semmle.label | 0 | -| tst.ts:453:10:453:25 | [CallExpr] loggedMethod("") | tst.ts:453:10:453:21 | [VarRef] loggedMethod | semmle.order | 0 | -| tst.ts:454:9:457:9 | [ClassInitializedMember,MethodDefinition] greet() ... } | tst.ts:453:9:453:25 | [Decorator] @loggedMethod("") | semmle.label | 1 | -| tst.ts:454:9:457:9 | [ClassInitializedMember,MethodDefinition] greet() ... } | tst.ts:453:9:453:25 | [Decorator] @loggedMethod("") | semmle.order | 1 | -| tst.ts:454:9:457:9 | [ClassInitializedMember,MethodDefinition] greet() ... } | tst.ts:454:9:454:13 | [Label] greet | semmle.label | 2 | -| tst.ts:454:9:457:9 | [ClassInitializedMember,MethodDefinition] greet() ... } | tst.ts:454:9:454:13 | [Label] greet | semmle.order | 2 | -| tst.ts:454:9:457:9 | [ClassInitializedMember,MethodDefinition] greet() ... } | tst.ts:454:9:457:9 | [FunctionExpr] greet() ... } | semmle.label | 3 | -| tst.ts:454:9:457:9 | [ClassInitializedMember,MethodDefinition] greet() ... } | tst.ts:454:9:457:9 | [FunctionExpr] greet() ... } | semmle.order | 3 | -| tst.ts:454:9:457:9 | [FunctionExpr] greet() ... } | tst.ts:454:17:457:9 | [BlockStmt] { ... } | semmle.label | 5 | -| tst.ts:454:9:457:9 | [FunctionExpr] greet() ... } | tst.ts:454:17:457:9 | [BlockStmt] { ... } | semmle.order | 5 | -| tst.ts:454:17:457:9 | [BlockStmt] { ... } | tst.ts:455:13:455:59 | [ExprStmt] console ... me}.`); | semmle.label | 1 | -| tst.ts:454:17:457:9 | [BlockStmt] { ... } | tst.ts:455:13:455:59 | [ExprStmt] console ... me}.`); | semmle.order | 1 | -| tst.ts:454:17:457:9 | [BlockStmt] { ... } | tst.ts:456:13:456:21 | [ReturnStmt] return 2; | semmle.label | 2 | -| tst.ts:454:17:457:9 | [BlockStmt] { ... } | tst.ts:456:13:456:21 | [ReturnStmt] return 2; | semmle.order | 2 | -| tst.ts:455:13:455:23 | [DotExpr] console.log | tst.ts:455:13:455:19 | [VarRef] console | semmle.label | 1 | -| tst.ts:455:13:455:23 | [DotExpr] console.log | tst.ts:455:13:455:19 | [VarRef] console | semmle.order | 1 | -| tst.ts:455:13:455:23 | [DotExpr] console.log | tst.ts:455:21:455:23 | [Label] log | semmle.label | 2 | -| tst.ts:455:13:455:23 | [DotExpr] console.log | tst.ts:455:21:455:23 | [Label] log | semmle.order | 2 | -| tst.ts:455:13:455:58 | [MethodCallExpr] console ... ame}.`) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:455:13:455:58 | [MethodCallExpr] console ... ame}.`) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:455:13:455:58 | [MethodCallExpr] console ... ame}.`) | tst.ts:455:13:455:23 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:455:13:455:58 | [MethodCallExpr] console ... ame}.`) | tst.ts:455:13:455:23 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:455:13:455:59 | [ExprStmt] console ... me}.`); | tst.ts:455:13:455:58 | [MethodCallExpr] console ... ame}.`) | semmle.label | 1 | -| tst.ts:455:13:455:59 | [ExprStmt] console ... me}.`); | tst.ts:455:13:455:58 | [MethodCallExpr] console ... ame}.`) | semmle.order | 1 | -| tst.ts:455:25:455:57 | [TemplateLiteral] `Hello, ... name}.` | tst.ts:455:26:455:43 | [TemplateElement] Hello, my name is | semmle.label | 1 | -| tst.ts:455:25:455:57 | [TemplateLiteral] `Hello, ... name}.` | tst.ts:455:26:455:43 | [TemplateElement] Hello, my name is | semmle.order | 1 | -| tst.ts:455:25:455:57 | [TemplateLiteral] `Hello, ... name}.` | tst.ts:455:46:455:54 | [DotExpr] this.name | semmle.label | 2 | -| tst.ts:455:25:455:57 | [TemplateLiteral] `Hello, ... name}.` | tst.ts:455:46:455:54 | [DotExpr] this.name | semmle.order | 2 | -| tst.ts:455:25:455:57 | [TemplateLiteral] `Hello, ... name}.` | tst.ts:455:56:455:56 | [TemplateElement] . | semmle.label | 3 | -| tst.ts:455:25:455:57 | [TemplateLiteral] `Hello, ... name}.` | tst.ts:455:56:455:56 | [TemplateElement] . | semmle.order | 3 | -| tst.ts:455:46:455:54 | [DotExpr] this.name | tst.ts:455:46:455:49 | [ThisExpr] this | semmle.label | 1 | -| tst.ts:455:46:455:54 | [DotExpr] this.name | tst.ts:455:46:455:49 | [ThisExpr] this | semmle.order | 1 | -| tst.ts:455:46:455:54 | [DotExpr] this.name | tst.ts:455:51:455:54 | [Label] name | semmle.label | 2 | -| tst.ts:455:46:455:54 | [DotExpr] this.name | tst.ts:455:51:455:54 | [Label] name | semmle.order | 2 | -| tst.ts:456:13:456:21 | [ReturnStmt] return 2; | tst.ts:456:20:456:20 | [Literal] 2 | semmle.label | 1 | -| tst.ts:456:13:456:21 | [ReturnStmt] return 2; | tst.ts:456:20:456:20 | [Literal] 2 | semmle.order | 1 | -| tst.ts:460:5:460:41 | [DeclStmt] const p = ... | tst.ts:460:11:460:40 | [VariableDeclarator] p = new ... greet() | semmle.label | 1 | -| tst.ts:460:5:460:41 | [DeclStmt] const p = ... | tst.ts:460:11:460:40 | [VariableDeclarator] p = new ... greet() | semmle.order | 1 | -| tst.ts:460:11:460:40 | [VariableDeclarator] p = new ... greet() | tst.ts:460:11:460:11 | [VarDecl] p | semmle.label | 1 | -| tst.ts:460:11:460:40 | [VariableDeclarator] p = new ... greet() | tst.ts:460:11:460:11 | [VarDecl] p | semmle.order | 1 | -| tst.ts:460:11:460:40 | [VariableDeclarator] p = new ... greet() | tst.ts:460:15:460:40 | [MethodCallExpr] new Per ... greet() | semmle.label | 2 | -| tst.ts:460:11:460:40 | [VariableDeclarator] p = new ... greet() | tst.ts:460:15:460:40 | [MethodCallExpr] new Per ... greet() | semmle.order | 2 | -| tst.ts:460:15:460:32 | [NewExpr] new Person("John") | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:460:15:460:32 | [NewExpr] new Person("John") | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:460:15:460:32 | [NewExpr] new Person("John") | tst.ts:460:19:460:24 | [VarRef] Person | semmle.label | 0 | -| tst.ts:460:15:460:32 | [NewExpr] new Person("John") | tst.ts:460:19:460:24 | [VarRef] Person | semmle.order | 0 | -| tst.ts:460:15:460:38 | [DotExpr] new Per ... ).greet | tst.ts:460:15:460:32 | [NewExpr] new Person("John") | semmle.label | 1 | -| tst.ts:460:15:460:38 | [DotExpr] new Per ... ).greet | tst.ts:460:15:460:32 | [NewExpr] new Person("John") | semmle.order | 1 | -| tst.ts:460:15:460:38 | [DotExpr] new Per ... ).greet | tst.ts:460:34:460:38 | [Label] greet | semmle.label | 2 | -| tst.ts:460:15:460:38 | [DotExpr] new Per ... ).greet | tst.ts:460:34:460:38 | [Label] greet | semmle.order | 2 | -| tst.ts:460:15:460:40 | [MethodCallExpr] new Per ... greet() | tst.ts:460:15:460:38 | [DotExpr] new Per ... ).greet | semmle.label | 0 | -| tst.ts:460:15:460:40 | [MethodCallExpr] new Per ... greet() | tst.ts:460:15:460:38 | [DotExpr] new Per ... ).greet | semmle.order | 0 | -| tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | file://:0:0:0:0 | (TypeParameters) | semmle.label | 2 | -| tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | file://:0:0:0:0 | (TypeParameters) | semmle.order | 2 | -| tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | tst.ts:462:22:462:38 | [VarDecl] myConstIdFunction | semmle.label | 0 | -| tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | tst.ts:462:22:462:38 | [VarDecl] myConstIdFunction | semmle.order | 0 | -| tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | tst.ts:462:85:462:85 | [LocalTypeAccess] T | semmle.label | 4 | -| tst.ts:462:5:462:86 | [FunctionDeclStmt] declare ... T): T; | tst.ts:462:85:462:85 | [LocalTypeAccess] T | semmle.order | 4 | -| tst.ts:462:40:462:72 | [TypeParameter] const T ... tring[] | tst.ts:462:46:462:46 | [Identifier] T | semmle.label | 1 | -| tst.ts:462:40:462:72 | [TypeParameter] const T ... tring[] | tst.ts:462:46:462:46 | [Identifier] T | semmle.order | 1 | -| tst.ts:462:40:462:72 | [TypeParameter] const T ... tring[] | tst.ts:462:56:462:72 | [ReadonlyTypeExpr] readonly string[] | semmle.label | 2 | -| tst.ts:462:40:462:72 | [TypeParameter] const T ... tring[] | tst.ts:462:56:462:72 | [ReadonlyTypeExpr] readonly string[] | semmle.order | 2 | -| tst.ts:462:56:462:72 | [ReadonlyTypeExpr] readonly string[] | tst.ts:462:65:462:72 | [ArrayTypeExpr] string[] | semmle.label | 1 | -| tst.ts:462:56:462:72 | [ReadonlyTypeExpr] readonly string[] | tst.ts:462:65:462:72 | [ArrayTypeExpr] string[] | semmle.order | 1 | -| tst.ts:462:65:462:72 | [ArrayTypeExpr] string[] | tst.ts:462:65:462:70 | [KeywordTypeExpr] string | semmle.label | 1 | -| tst.ts:462:65:462:72 | [ArrayTypeExpr] string[] | tst.ts:462:65:462:70 | [KeywordTypeExpr] string | semmle.order | 1 | -| tst.ts:462:75:462:78 | [SimpleParameter] args | tst.ts:462:81:462:81 | [LocalTypeAccess] T | semmle.label | -2 | -| tst.ts:462:75:462:78 | [SimpleParameter] args | tst.ts:462:81:462:81 | [LocalTypeAccess] T | semmle.order | -2 | -| tst.ts:465:5:465:51 | [DeclStmt] const foo = ... | tst.ts:465:11:465:50 | [VariableDeclarator] foo = m ... ,"c"]) | semmle.label | 1 | -| tst.ts:465:5:465:51 | [DeclStmt] const foo = ... | tst.ts:465:11:465:50 | [VariableDeclarator] foo = m ... ,"c"]) | semmle.order | 1 | -| tst.ts:465:11:465:50 | [VariableDeclarator] foo = m ... ,"c"]) | tst.ts:465:11:465:13 | [VarDecl] foo | semmle.label | 1 | -| tst.ts:465:11:465:50 | [VariableDeclarator] foo = m ... ,"c"]) | tst.ts:465:11:465:13 | [VarDecl] foo | semmle.order | 1 | -| tst.ts:465:11:465:50 | [VariableDeclarator] foo = m ... ,"c"]) | tst.ts:465:17:465:50 | [CallExpr] myConst ... ,"c"]) | semmle.label | 2 | -| tst.ts:465:11:465:50 | [VariableDeclarator] foo = m ... ,"c"]) | tst.ts:465:17:465:50 | [CallExpr] myConst ... ,"c"]) | semmle.order | 2 | -| tst.ts:465:17:465:50 | [CallExpr] myConst ... ,"c"]) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:465:17:465:50 | [CallExpr] myConst ... ,"c"]) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:465:17:465:50 | [CallExpr] myConst ... ,"c"]) | tst.ts:465:17:465:33 | [VarRef] myConstIdFunction | semmle.label | 0 | -| tst.ts:465:17:465:50 | [CallExpr] myConst ... ,"c"]) | tst.ts:465:17:465:33 | [VarRef] myConstIdFunction | semmle.order | 0 | -| tst.ts:465:35:465:49 | [ArrayExpr] ["a", "b" ,"c"] | tst.ts:465:36:465:38 | [Literal] "a" | semmle.label | 1 | -| tst.ts:465:35:465:49 | [ArrayExpr] ["a", "b" ,"c"] | tst.ts:465:36:465:38 | [Literal] "a" | semmle.order | 1 | -| tst.ts:465:35:465:49 | [ArrayExpr] ["a", "b" ,"c"] | tst.ts:465:41:465:43 | [Literal] "b" | semmle.label | 2 | -| tst.ts:465:35:465:49 | [ArrayExpr] ["a", "b" ,"c"] | tst.ts:465:41:465:43 | [Literal] "b" | semmle.order | 2 | -| tst.ts:465:35:465:49 | [ArrayExpr] ["a", "b" ,"c"] | tst.ts:465:46:465:48 | [Literal] "c" | semmle.label | 3 | -| tst.ts:465:35:465:49 | [ArrayExpr] ["a", "b" ,"c"] | tst.ts:465:46:465:48 | [Literal] "c" | semmle.order | 3 | -| tst.ts:467:5:467:21 | [DeclStmt] const b = ... | tst.ts:467:11:467:20 | [VariableDeclarator] b = foo[1] | semmle.label | 1 | -| tst.ts:467:5:467:21 | [DeclStmt] const b = ... | tst.ts:467:11:467:20 | [VariableDeclarator] b = foo[1] | semmle.order | 1 | -| tst.ts:467:11:467:20 | [VariableDeclarator] b = foo[1] | tst.ts:467:11:467:11 | [VarDecl] b | semmle.label | 1 | -| tst.ts:467:11:467:20 | [VariableDeclarator] b = foo[1] | tst.ts:467:11:467:11 | [VarDecl] b | semmle.order | 1 | -| tst.ts:467:11:467:20 | [VariableDeclarator] b = foo[1] | tst.ts:467:15:467:20 | [IndexExpr] foo[1] | semmle.label | 2 | -| tst.ts:467:11:467:20 | [VariableDeclarator] b = foo[1] | tst.ts:467:15:467:20 | [IndexExpr] foo[1] | semmle.order | 2 | -| tst.ts:467:15:467:20 | [IndexExpr] foo[1] | tst.ts:467:15:467:17 | [VarRef] foo | semmle.label | 1 | -| tst.ts:467:15:467:20 | [IndexExpr] foo[1] | tst.ts:467:15:467:17 | [VarRef] foo | semmle.order | 1 | -| tst.ts:467:15:467:20 | [IndexExpr] foo[1] | tst.ts:467:19:467:19 | [Literal] 1 | semmle.label | 2 | -| tst.ts:467:15:467:20 | [IndexExpr] foo[1] | tst.ts:467:19:467:19 | [Literal] 1 | semmle.order | 2 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:472:8:472:11 | [VarDecl] TS52 | semmle.label | 1 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:472:8:472:11 | [VarDecl] TS52 | semmle.order | 1 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:473:5:476:5 | [ClassDefinition,TypeDefinition] class S ... ; } | semmle.label | 2 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:473:5:476:5 | [ClassDefinition,TypeDefinition] class S ... ; } | semmle.order | 2 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:478:5:478:44 | [ExprStmt] console ... data]); | semmle.label | 3 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:478:5:478:44 | [ExprStmt] console ... data]); | semmle.order | 3 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:481:5:481:34 | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | semmle.label | 4 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:481:5:481:34 | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | semmle.order | 4 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:483:5:483:60 | [ExprStmt] console ... ring>); | semmle.label | 5 | -| tst.ts:472:1:484:1 | [NamespaceDeclaration] module ... ng>); } | tst.ts:483:5:483:60 | [ExprStmt] console ... ring>); | semmle.order | 5 | -| tst.ts:473:5:476:5 | [ClassDefinition,TypeDefinition] class S ... ; } | tst.ts:473:11:473:19 | [VarDecl] SomeClass | semmle.label | 1 | -| tst.ts:473:5:476:5 | [ClassDefinition,TypeDefinition] class S ... ; } | tst.ts:473:11:473:19 | [VarDecl] SomeClass | semmle.order | 1 | -| tst.ts:473:5:476:5 | [ClassDefinition,TypeDefinition] class S ... ; } | tst.ts:473:21:473:20 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | 2 | -| tst.ts:473:5:476:5 | [ClassDefinition,TypeDefinition] class S ... ; } | tst.ts:473:21:473:20 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.order | 2 | -| tst.ts:473:5:476:5 | [ClassDefinition,TypeDefinition] class S ... ; } | tst.ts:475:9:475:18 | [FieldDeclaration] foo = 123; | semmle.label | 3 | -| tst.ts:473:5:476:5 | [ClassDefinition,TypeDefinition] class S ... ; } | tst.ts:475:9:475:18 | [FieldDeclaration] foo = 123; | semmle.order | 3 | -| tst.ts:473:21:473:20 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:473:21:473:20 | [FunctionExpr] () {} | semmle.label | 2 | -| tst.ts:473:21:473:20 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:473:21:473:20 | [FunctionExpr] () {} | semmle.order | 2 | -| tst.ts:473:21:473:20 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:473:21:473:20 | [Label] constructor | semmle.label | 1 | -| tst.ts:473:21:473:20 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:473:21:473:20 | [Label] constructor | semmle.order | 1 | -| tst.ts:473:21:473:20 | [FunctionExpr] () {} | tst.ts:473:21:473:20 | [BlockStmt] {} | semmle.label | 5 | -| tst.ts:473:21:473:20 | [FunctionExpr] () {} | tst.ts:473:21:473:20 | [BlockStmt] {} | semmle.order | 5 | -| tst.ts:474:9:474:36 | [Decorator] @((_tar ... => {}) | tst.ts:474:10:474:36 | [ParExpr] ((_targ ... => {}) | semmle.label | 1 | -| tst.ts:474:9:474:36 | [Decorator] @((_tar ... => {}) | tst.ts:474:10:474:36 | [ParExpr] ((_targ ... => {}) | semmle.order | 1 | -| tst.ts:474:10:474:36 | [ParExpr] ((_targ ... => {}) | tst.ts:474:11:474:35 | [ArrowFunctionExpr] (_targe ... ) => {} | semmle.label | 1 | -| tst.ts:474:10:474:36 | [ParExpr] ((_targ ... => {}) | tst.ts:474:11:474:35 | [ArrowFunctionExpr] (_targe ... ) => {} | semmle.order | 1 | -| tst.ts:474:11:474:35 | [ArrowFunctionExpr] (_targe ... ) => {} | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:474:11:474:35 | [ArrowFunctionExpr] (_targe ... ) => {} | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:474:11:474:35 | [ArrowFunctionExpr] (_targe ... ) => {} | tst.ts:474:34:474:35 | [BlockStmt] {} | semmle.label | 5 | -| tst.ts:474:11:474:35 | [ArrowFunctionExpr] (_targe ... ) => {} | tst.ts:474:34:474:35 | [BlockStmt] {} | semmle.order | 5 | -| tst.ts:475:9:475:18 | [FieldDeclaration] foo = 123; | tst.ts:474:9:474:36 | [Decorator] @((_tar ... => {}) | semmle.label | 1 | -| tst.ts:475:9:475:18 | [FieldDeclaration] foo = 123; | tst.ts:474:9:474:36 | [Decorator] @((_tar ... => {}) | semmle.order | 1 | -| tst.ts:475:9:475:18 | [FieldDeclaration] foo = 123; | tst.ts:475:9:475:11 | [Label] foo | semmle.label | 2 | -| tst.ts:475:9:475:18 | [FieldDeclaration] foo = 123; | tst.ts:475:9:475:11 | [Label] foo | semmle.order | 2 | -| tst.ts:475:9:475:18 | [FieldDeclaration] foo = 123; | tst.ts:475:15:475:17 | [Literal] 123 | semmle.label | 3 | -| tst.ts:475:9:475:18 | [FieldDeclaration] foo = 123; | tst.ts:475:15:475:17 | [Literal] 123 | semmle.order | 3 | -| tst.ts:478:5:478:15 | [DotExpr] console.log | tst.ts:478:5:478:11 | [VarRef] console | semmle.label | 1 | -| tst.ts:478:5:478:15 | [DotExpr] console.log | tst.ts:478:5:478:11 | [VarRef] console | semmle.order | 1 | -| tst.ts:478:5:478:15 | [DotExpr] console.log | tst.ts:478:13:478:15 | [Label] log | semmle.label | 2 | -| tst.ts:478:5:478:15 | [DotExpr] console.log | tst.ts:478:13:478:15 | [Label] log | semmle.order | 2 | -| tst.ts:478:5:478:43 | [MethodCallExpr] console ... adata]) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:478:5:478:43 | [MethodCallExpr] console ... adata]) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:478:5:478:43 | [MethodCallExpr] console ... adata]) | tst.ts:478:5:478:15 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:478:5:478:43 | [MethodCallExpr] console ... adata]) | tst.ts:478:5:478:15 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:478:5:478:44 | [ExprStmt] console ... data]); | tst.ts:478:5:478:43 | [MethodCallExpr] console ... adata]) | semmle.label | 1 | -| tst.ts:478:5:478:44 | [ExprStmt] console ... data]); | tst.ts:478:5:478:43 | [MethodCallExpr] console ... adata]) | semmle.order | 1 | -| tst.ts:478:17:478:42 | [IndexExpr] SomeCla ... tadata] | tst.ts:478:17:478:25 | [VarRef] SomeClass | semmle.label | 1 | -| tst.ts:478:17:478:42 | [IndexExpr] SomeCla ... tadata] | tst.ts:478:17:478:25 | [VarRef] SomeClass | semmle.order | 1 | -| tst.ts:478:17:478:42 | [IndexExpr] SomeCla ... tadata] | tst.ts:478:27:478:41 | [DotExpr] Symbol.metadata | semmle.label | 2 | -| tst.ts:478:17:478:42 | [IndexExpr] SomeCla ... tadata] | tst.ts:478:27:478:41 | [DotExpr] Symbol.metadata | semmle.order | 2 | -| tst.ts:478:27:478:41 | [DotExpr] Symbol.metadata | tst.ts:478:27:478:32 | [VarRef] Symbol | semmle.label | 1 | -| tst.ts:478:27:478:41 | [DotExpr] Symbol.metadata | tst.ts:478:27:478:32 | [VarRef] Symbol | semmle.order | 1 | -| tst.ts:478:27:478:41 | [DotExpr] Symbol.metadata | tst.ts:478:34:478:41 | [Label] metadata | semmle.label | 2 | -| tst.ts:478:27:478:41 | [DotExpr] Symbol.metadata | tst.ts:478:34:478:41 | [Label] metadata | semmle.order | 2 | -| tst.ts:481:5:481:34 | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| tst.ts:481:5:481:34 | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| tst.ts:481:5:481:34 | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | tst.ts:481:10:481:14 | [Identifier] Pair3 | semmle.label | 1 | -| tst.ts:481:5:481:34 | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | tst.ts:481:10:481:14 | [Identifier] Pair3 | semmle.order | 1 | -| tst.ts:481:5:481:34 | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | tst.ts:481:21:481:33 | [TupleTypeExpr] [first: T, T] | semmle.label | 3 | -| tst.ts:481:5:481:34 | [TypeAliasDeclaration,TypeDefinition] type Pa ... T, T]; | tst.ts:481:21:481:33 | [TupleTypeExpr] [first: T, T] | semmle.order | 3 | -| tst.ts:481:16:481:16 | [TypeParameter] T | tst.ts:481:16:481:16 | [Identifier] T | semmle.label | 1 | -| tst.ts:481:16:481:16 | [TypeParameter] T | tst.ts:481:16:481:16 | [Identifier] T | semmle.order | 1 | -| tst.ts:481:21:481:33 | [TupleTypeExpr] [first: T, T] | tst.ts:481:22:481:26 | [Identifier] first | semmle.label | 1 | -| tst.ts:481:21:481:33 | [TupleTypeExpr] [first: T, T] | tst.ts:481:22:481:26 | [Identifier] first | semmle.order | 1 | -| tst.ts:481:21:481:33 | [TupleTypeExpr] [first: T, T] | tst.ts:481:29:481:29 | [LocalTypeAccess] T | semmle.label | 2 | -| tst.ts:481:21:481:33 | [TupleTypeExpr] [first: T, T] | tst.ts:481:29:481:29 | [LocalTypeAccess] T | semmle.order | 2 | -| tst.ts:481:21:481:33 | [TupleTypeExpr] [first: T, T] | tst.ts:481:32:481:32 | [LocalTypeAccess] T | semmle.label | 3 | -| tst.ts:481:21:481:33 | [TupleTypeExpr] [first: T, T] | tst.ts:481:32:481:32 | [LocalTypeAccess] T | semmle.order | 3 | -| tst.ts:483:5:483:15 | [DotExpr] console.log | tst.ts:483:5:483:11 | [VarRef] console | semmle.label | 1 | -| tst.ts:483:5:483:15 | [DotExpr] console.log | tst.ts:483:5:483:11 | [VarRef] console | semmle.order | 1 | -| tst.ts:483:5:483:15 | [DotExpr] console.log | tst.ts:483:13:483:15 | [Label] log | semmle.label | 2 | -| tst.ts:483:5:483:15 | [DotExpr] console.log | tst.ts:483:13:483:15 | [Label] log | semmle.order | 2 | -| tst.ts:483:5:483:59 | [MethodCallExpr] console ... tring>) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:483:5:483:59 | [MethodCallExpr] console ... tring>) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:483:5:483:59 | [MethodCallExpr] console ... tring>) | tst.ts:483:5:483:15 | [DotExpr] console.log | semmle.label | 0 | -| tst.ts:483:5:483:59 | [MethodCallExpr] console ... tring>) | tst.ts:483:5:483:15 | [DotExpr] console.log | semmle.order | 0 | -| tst.ts:483:5:483:60 | [ExprStmt] console ... ring>); | tst.ts:483:5:483:59 | [MethodCallExpr] console ... tring>) | semmle.label | 1 | -| tst.ts:483:5:483:60 | [ExprStmt] console ... ring>); | tst.ts:483:5:483:59 | [MethodCallExpr] console ... tring>) | semmle.order | 1 | -| tst.ts:483:17:483:34 | [ArrayExpr] ["hello", "world"] | tst.ts:483:18:483:24 | [Literal] "hello" | semmle.label | 1 | -| tst.ts:483:17:483:34 | [ArrayExpr] ["hello", "world"] | tst.ts:483:18:483:24 | [Literal] "hello" | semmle.order | 1 | -| tst.ts:483:17:483:34 | [ArrayExpr] ["hello", "world"] | tst.ts:483:27:483:33 | [Literal] "world" | semmle.label | 2 | -| tst.ts:483:17:483:34 | [ArrayExpr] ["hello", "world"] | tst.ts:483:27:483:33 | [Literal] "world" | semmle.order | 2 | -| tst.ts:483:17:483:58 | [SatisfiesExpr] ["hello ... string> | tst.ts:483:17:483:34 | [ArrayExpr] ["hello", "world"] | semmle.label | 1 | -| tst.ts:483:17:483:58 | [SatisfiesExpr] ["hello ... string> | tst.ts:483:17:483:34 | [ArrayExpr] ["hello", "world"] | semmle.order | 1 | -| tst.ts:483:17:483:58 | [SatisfiesExpr] ["hello ... string> | tst.ts:483:46:483:58 | [GenericTypeExpr] Pair3 | semmle.label | 2 | -| tst.ts:483:17:483:58 | [SatisfiesExpr] ["hello ... string> | tst.ts:483:46:483:58 | [GenericTypeExpr] Pair3 | semmle.order | 2 | -| tst.ts:483:46:483:58 | [GenericTypeExpr] Pair3 | tst.ts:483:46:483:50 | [LocalTypeAccess] Pair3 | semmle.label | 1 | -| tst.ts:483:46:483:58 | [GenericTypeExpr] Pair3 | tst.ts:483:46:483:50 | [LocalTypeAccess] Pair3 | semmle.order | 1 | -| tst.ts:483:46:483:58 | [GenericTypeExpr] Pair3 | tst.ts:483:52:483:57 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:483:46:483:58 | [GenericTypeExpr] Pair3 | tst.ts:483:52:483:57 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | tst.ts:486:8:486:11 | [VarDecl] TS54 | semmle.label | 1 | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | tst.ts:486:8:486:11 | [VarDecl] TS54 | semmle.order | 1 | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | semmle.label | 2 | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | semmle.order | 2 | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | tst.ts:491:3:491:58 | [ExprStmt] createS ... llow"); | semmle.label | 3 | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | tst.ts:491:3:491:58 | [ExprStmt] createS ... llow"); | semmle.order | 3 | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | tst.ts:493:3:495:5 | [DeclStmt] const myObj = ... | semmle.label | 4 | -| tst.ts:486:1:496:1 | [NamespaceDeclaration] module ... }); } | tst.ts:493:3:495:5 | [DeclStmt] const myObj = ... | semmle.order | 4 | -| tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | file://:0:0:0:0 | (TypeParameters) | semmle.label | 2 | -| tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | file://:0:0:0:0 | (TypeParameters) | semmle.order | 2 | -| tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | tst.ts:487:12:487:28 | [VarDecl] createStreetLight | semmle.label | 0 | -| tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | tst.ts:487:12:487:28 | [VarDecl] createStreetLight | semmle.order | 0 | -| tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | tst.ts:487:88:489:3 | [BlockStmt] { r ... 0]; } | semmle.label | 5 | -| tst.ts:487:3:489:3 | [FunctionDeclStmt] functio ... 0]; } | tst.ts:487:88:489:3 | [BlockStmt] { r ... 0]; } | semmle.order | 5 | -| tst.ts:487:30:487:45 | [TypeParameter] C extends string | tst.ts:487:30:487:30 | [Identifier] C | semmle.label | 1 | -| tst.ts:487:30:487:45 | [TypeParameter] C extends string | tst.ts:487:30:487:30 | [Identifier] C | semmle.order | 1 | -| tst.ts:487:30:487:45 | [TypeParameter] C extends string | tst.ts:487:40:487:45 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:487:30:487:45 | [TypeParameter] C extends string | tst.ts:487:40:487:45 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:487:48:487:53 | [SimpleParameter] colors | tst.ts:487:56:487:58 | [ArrayTypeExpr] C[] | semmle.label | -2 | -| tst.ts:487:48:487:53 | [SimpleParameter] colors | tst.ts:487:56:487:58 | [ArrayTypeExpr] C[] | semmle.order | -2 | -| tst.ts:487:56:487:58 | [ArrayTypeExpr] C[] | tst.ts:487:56:487:56 | [LocalTypeAccess] C | semmle.label | 1 | -| tst.ts:487:56:487:58 | [ArrayTypeExpr] C[] | tst.ts:487:56:487:56 | [LocalTypeAccess] C | semmle.order | 1 | -| tst.ts:487:61:487:72 | [SimpleParameter] defaultColor | tst.ts:487:76:487:85 | [GenericTypeExpr] NoInfer | semmle.label | -2 | -| tst.ts:487:61:487:72 | [SimpleParameter] defaultColor | tst.ts:487:76:487:85 | [GenericTypeExpr] NoInfer | semmle.order | -2 | -| tst.ts:487:76:487:85 | [GenericTypeExpr] NoInfer | tst.ts:487:76:487:82 | [LocalTypeAccess] NoInfer | semmle.label | 1 | -| tst.ts:487:76:487:85 | [GenericTypeExpr] NoInfer | tst.ts:487:76:487:82 | [LocalTypeAccess] NoInfer | semmle.order | 1 | -| tst.ts:487:76:487:85 | [GenericTypeExpr] NoInfer | tst.ts:487:84:487:84 | [LocalTypeAccess] C | semmle.label | 2 | -| tst.ts:487:76:487:85 | [GenericTypeExpr] NoInfer | tst.ts:487:84:487:84 | [LocalTypeAccess] C | semmle.order | 2 | -| tst.ts:487:88:489:3 | [BlockStmt] { r ... 0]; } | tst.ts:488:5:488:21 | [ReturnStmt] return colors[0]; | semmle.label | 1 | -| tst.ts:487:88:489:3 | [BlockStmt] { r ... 0]; } | tst.ts:488:5:488:21 | [ReturnStmt] return colors[0]; | semmle.order | 1 | -| tst.ts:488:5:488:21 | [ReturnStmt] return colors[0]; | tst.ts:488:12:488:20 | [IndexExpr] colors[0] | semmle.label | 1 | -| tst.ts:488:5:488:21 | [ReturnStmt] return colors[0]; | tst.ts:488:12:488:20 | [IndexExpr] colors[0] | semmle.order | 1 | -| tst.ts:488:12:488:20 | [IndexExpr] colors[0] | tst.ts:488:12:488:17 | [VarRef] colors | semmle.label | 1 | -| tst.ts:488:12:488:20 | [IndexExpr] colors[0] | tst.ts:488:12:488:17 | [VarRef] colors | semmle.order | 1 | -| tst.ts:488:12:488:20 | [IndexExpr] colors[0] | tst.ts:488:19:488:19 | [Literal] 0 | semmle.label | 2 | -| tst.ts:488:12:488:20 | [IndexExpr] colors[0] | tst.ts:488:19:488:19 | [Literal] 0 | semmle.order | 2 | -| tst.ts:491:3:491:57 | [CallExpr] createS ... ellow") | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:491:3:491:57 | [CallExpr] createS ... ellow") | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:491:3:491:57 | [CallExpr] createS ... ellow") | tst.ts:491:3:491:19 | [VarRef] createStreetLight | semmle.label | 0 | -| tst.ts:491:3:491:57 | [CallExpr] createS ... ellow") | tst.ts:491:3:491:19 | [VarRef] createStreetLight | semmle.order | 0 | -| tst.ts:491:3:491:58 | [ExprStmt] createS ... llow"); | tst.ts:491:3:491:57 | [CallExpr] createS ... ellow") | semmle.label | 1 | -| tst.ts:491:3:491:58 | [ExprStmt] createS ... llow"); | tst.ts:491:3:491:57 | [CallExpr] createS ... ellow") | semmle.order | 1 | -| tst.ts:491:21:491:46 | [ArrayExpr] ["red", ... green"] | tst.ts:491:22:491:26 | [Literal] "red" | semmle.label | 1 | -| tst.ts:491:21:491:46 | [ArrayExpr] ["red", ... green"] | tst.ts:491:22:491:26 | [Literal] "red" | semmle.order | 1 | -| tst.ts:491:21:491:46 | [ArrayExpr] ["red", ... green"] | tst.ts:491:29:491:36 | [Literal] "yellow" | semmle.label | 2 | -| tst.ts:491:21:491:46 | [ArrayExpr] ["red", ... green"] | tst.ts:491:29:491:36 | [Literal] "yellow" | semmle.order | 2 | -| tst.ts:491:21:491:46 | [ArrayExpr] ["red", ... green"] | tst.ts:491:39:491:45 | [Literal] "green" | semmle.label | 3 | -| tst.ts:491:21:491:46 | [ArrayExpr] ["red", ... green"] | tst.ts:491:39:491:45 | [Literal] "green" | semmle.order | 3 | -| tst.ts:493:3:495:5 | [DeclStmt] const myObj = ... | tst.ts:493:9:495:4 | [VariableDeclarator] myObj = ... "; }) | semmle.label | 1 | -| tst.ts:493:3:495:5 | [DeclStmt] const myObj = ... | tst.ts:493:9:495:4 | [VariableDeclarator] myObj = ... "; }) | semmle.order | 1 | -| tst.ts:493:9:495:4 | [VariableDeclarator] myObj = ... "; }) | tst.ts:493:9:493:13 | [VarDecl] myObj | semmle.label | 1 | -| tst.ts:493:9:495:4 | [VariableDeclarator] myObj = ... "; }) | tst.ts:493:9:493:13 | [VarDecl] myObj | semmle.order | 1 | -| tst.ts:493:9:495:4 | [VariableDeclarator] myObj = ... "; }) | tst.ts:493:17:495:4 | [MethodCallExpr] Object. ... "; }) | semmle.label | 2 | -| tst.ts:493:9:495:4 | [VariableDeclarator] myObj = ... "; }) | tst.ts:493:17:495:4 | [MethodCallExpr] Object. ... "; }) | semmle.order | 2 | -| tst.ts:493:17:493:30 | [DotExpr] Object.groupBy | tst.ts:493:17:493:22 | [VarRef] Object | semmle.label | 1 | -| tst.ts:493:17:493:30 | [DotExpr] Object.groupBy | tst.ts:493:17:493:22 | [VarRef] Object | semmle.order | 1 | -| tst.ts:493:17:493:30 | [DotExpr] Object.groupBy | tst.ts:493:24:493:30 | [Label] groupBy | semmle.label | 2 | -| tst.ts:493:17:493:30 | [DotExpr] Object.groupBy | tst.ts:493:24:493:30 | [Label] groupBy | semmle.order | 2 | -| tst.ts:493:17:495:4 | [MethodCallExpr] Object. ... "; }) | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:493:17:495:4 | [MethodCallExpr] Object. ... "; }) | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:493:17:495:4 | [MethodCallExpr] Object. ... "; }) | tst.ts:493:17:493:30 | [DotExpr] Object.groupBy | semmle.label | 0 | -| tst.ts:493:17:495:4 | [MethodCallExpr] Object. ... "; }) | tst.ts:493:17:493:30 | [DotExpr] Object.groupBy | semmle.order | 0 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:33:493:33 | [Literal] 0 | semmle.label | 1 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:33:493:33 | [Literal] 0 | semmle.order | 1 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:36:493:36 | [Literal] 1 | semmle.label | 2 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:36:493:36 | [Literal] 1 | semmle.order | 2 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:39:493:39 | [Literal] 2 | semmle.label | 3 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:39:493:39 | [Literal] 2 | semmle.order | 3 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:42:493:42 | [Literal] 3 | semmle.label | 4 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:42:493:42 | [Literal] 3 | semmle.order | 4 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:45:493:45 | [Literal] 4 | semmle.label | 5 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:45:493:45 | [Literal] 4 | semmle.order | 5 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:48:493:48 | [Literal] 5 | semmle.label | 6 | -| tst.ts:493:32:493:49 | [ArrayExpr] [0, 1, 2, 3, 4, 5] | tst.ts:493:48:493:48 | [Literal] 5 | semmle.order | 6 | -| tst.ts:493:52:495:3 | [ArrowFunctionExpr] (num, i ... d"; } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:493:52:495:3 | [ArrowFunctionExpr] (num, i ... d"; } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:493:52:495:3 | [ArrowFunctionExpr] (num, i ... d"; } | tst.ts:493:68:495:3 | [BlockStmt] { r ... d"; } | semmle.label | 5 | -| tst.ts:493:52:495:3 | [ArrowFunctionExpr] (num, i ... d"; } | tst.ts:493:68:495:3 | [BlockStmt] { r ... d"; } | semmle.order | 5 | -| tst.ts:493:68:495:3 | [BlockStmt] { r ... d"; } | tst.ts:494:5:494:41 | [ReturnStmt] return ... "odd"; | semmle.label | 1 | -| tst.ts:493:68:495:3 | [BlockStmt] { r ... d"; } | tst.ts:494:5:494:41 | [ReturnStmt] return ... "odd"; | semmle.order | 1 | -| tst.ts:494:5:494:41 | [ReturnStmt] return ... "odd"; | tst.ts:494:12:494:40 | [ConditionalExpr] num % 2 ... : "odd" | semmle.label | 1 | -| tst.ts:494:5:494:41 | [ReturnStmt] return ... "odd"; | tst.ts:494:12:494:40 | [ConditionalExpr] num % 2 ... : "odd" | semmle.order | 1 | -| tst.ts:494:12:494:18 | [BinaryExpr] num % 2 | tst.ts:494:12:494:14 | [VarRef] num | semmle.label | 1 | -| tst.ts:494:12:494:18 | [BinaryExpr] num % 2 | tst.ts:494:12:494:14 | [VarRef] num | semmle.order | 1 | -| tst.ts:494:12:494:18 | [BinaryExpr] num % 2 | tst.ts:494:18:494:18 | [Literal] 2 | semmle.label | 2 | -| tst.ts:494:12:494:18 | [BinaryExpr] num % 2 | tst.ts:494:18:494:18 | [Literal] 2 | semmle.order | 2 | -| tst.ts:494:12:494:24 | [BinaryExpr] num % 2 === 0 | tst.ts:494:12:494:18 | [BinaryExpr] num % 2 | semmle.label | 1 | -| tst.ts:494:12:494:24 | [BinaryExpr] num % 2 === 0 | tst.ts:494:12:494:18 | [BinaryExpr] num % 2 | semmle.order | 1 | -| tst.ts:494:12:494:24 | [BinaryExpr] num % 2 === 0 | tst.ts:494:24:494:24 | [Literal] 0 | semmle.label | 2 | -| tst.ts:494:12:494:24 | [BinaryExpr] num % 2 === 0 | tst.ts:494:24:494:24 | [Literal] 0 | semmle.order | 2 | -| tst.ts:494:12:494:40 | [ConditionalExpr] num % 2 ... : "odd" | tst.ts:494:12:494:24 | [BinaryExpr] num % 2 === 0 | semmle.label | 1 | -| tst.ts:494:12:494:40 | [ConditionalExpr] num % 2 ... : "odd" | tst.ts:494:12:494:24 | [BinaryExpr] num % 2 === 0 | semmle.order | 1 | -| tst.ts:494:12:494:40 | [ConditionalExpr] num % 2 ... : "odd" | tst.ts:494:28:494:33 | [Literal] "even" | semmle.label | 2 | -| tst.ts:494:12:494:40 | [ConditionalExpr] num % 2 ... : "odd" | tst.ts:494:28:494:33 | [Literal] "even" | semmle.order | 2 | -| tst.ts:494:12:494:40 | [ConditionalExpr] num % 2 ... : "odd" | tst.ts:494:36:494:40 | [Literal] "odd" | semmle.label | 3 | -| tst.ts:494:12:494:40 | [ConditionalExpr] num % 2 ... : "odd" | tst.ts:494:36:494:40 | [Literal] "odd" | semmle.order | 3 | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | tst.ts:498:8:498:11 | [VarDecl] TS55 | semmle.label | 1 | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | tst.ts:498:8:498:11 | [VarDecl] TS55 | semmle.order | 1 | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | tst.ts:499:3:500:40 | [DeclStmt] const strings = ... | semmle.label | 2 | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | tst.ts:499:3:500:40 | [DeclStmt] const strings = ... | semmle.order | 2 | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | tst.ts:502:3:504:3 | [ForOfStmt] for (co ... 5.4 } | semmle.label | 3 | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | tst.ts:502:3:504:3 | [ForOfStmt] for (co ... 5.4 } | semmle.order | 3 | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | tst.ts:506:3:510:3 | [FunctionDeclStmt] functio ... } } | semmle.label | 4 | -| tst.ts:498:1:511:1 | [NamespaceDeclaration] module ... } } } | tst.ts:506:3:510:3 | [FunctionDeclStmt] functio ... } } | semmle.order | 4 | -| tst.ts:499:3:500:40 | [DeclStmt] const strings = ... | tst.ts:499:9:500:39 | [VariableDeclarator] strings ... tring") | semmle.label | 1 | -| tst.ts:499:3:500:40 | [DeclStmt] const strings = ... | tst.ts:499:9:500:39 | [VariableDeclarator] strings ... tring") | semmle.order | 1 | -| tst.ts:499:9:500:39 | [VariableDeclarator] strings ... tring") | tst.ts:499:9:499:15 | [VarDecl] strings | semmle.label | 1 | -| tst.ts:499:9:500:39 | [VariableDeclarator] strings ... tring") | tst.ts:499:9:499:15 | [VarDecl] strings | semmle.order | 1 | -| tst.ts:499:9:500:39 | [VariableDeclarator] strings ... tring") | tst.ts:499:19:500:39 | [MethodCallExpr] (["foo" ... tring") | semmle.label | 2 | -| tst.ts:499:9:500:39 | [VariableDeclarator] strings ... tring") | tst.ts:499:19:500:39 | [MethodCallExpr] (["foo" ... tring") | semmle.order | 2 | -| tst.ts:499:19:499:32 | [ParExpr] (["foo", 123]) | tst.ts:499:20:499:31 | [ArrayExpr] ["foo", 123] | semmle.label | 1 | -| tst.ts:499:19:499:32 | [ParExpr] (["foo", 123]) | tst.ts:499:20:499:31 | [ArrayExpr] ["foo", 123] | semmle.order | 1 | -| tst.ts:499:19:500:11 | [DotExpr] (["foo" ... .filter | tst.ts:499:19:499:32 | [ParExpr] (["foo", 123]) | semmle.label | 1 | -| tst.ts:499:19:500:11 | [DotExpr] (["foo" ... .filter | tst.ts:499:19:499:32 | [ParExpr] (["foo", 123]) | semmle.order | 1 | -| tst.ts:499:19:500:11 | [DotExpr] (["foo" ... .filter | tst.ts:500:6:500:11 | [Label] filter | semmle.label | 2 | -| tst.ts:499:19:500:11 | [DotExpr] (["foo" ... .filter | tst.ts:500:6:500:11 | [Label] filter | semmle.order | 2 | -| tst.ts:499:19:500:39 | [MethodCallExpr] (["foo" ... tring") | file://:0:0:0:0 | (Arguments) | semmle.label | 1 | -| tst.ts:499:19:500:39 | [MethodCallExpr] (["foo" ... tring") | file://:0:0:0:0 | (Arguments) | semmle.order | 1 | -| tst.ts:499:19:500:39 | [MethodCallExpr] (["foo" ... tring") | tst.ts:499:19:500:11 | [DotExpr] (["foo" ... .filter | semmle.label | 0 | -| tst.ts:499:19:500:39 | [MethodCallExpr] (["foo" ... tring") | tst.ts:499:19:500:11 | [DotExpr] (["foo" ... .filter | semmle.order | 0 | -| tst.ts:499:20:499:31 | [ArrayExpr] ["foo", 123] | tst.ts:499:21:499:25 | [Literal] "foo" | semmle.label | 1 | -| tst.ts:499:20:499:31 | [ArrayExpr] ["foo", 123] | tst.ts:499:21:499:25 | [Literal] "foo" | semmle.order | 1 | -| tst.ts:499:20:499:31 | [ArrayExpr] ["foo", 123] | tst.ts:499:28:499:30 | [Literal] 123 | semmle.label | 2 | -| tst.ts:499:20:499:31 | [ArrayExpr] ["foo", 123] | tst.ts:499:28:499:30 | [Literal] 123 | semmle.order | 2 | -| tst.ts:500:13:500:38 | [ArrowFunctionExpr] s => ty ... string" | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:500:13:500:38 | [ArrowFunctionExpr] s => ty ... string" | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:500:13:500:38 | [ArrowFunctionExpr] s => ty ... string" | tst.ts:500:18:500:38 | [BinaryExpr] typeof ... string" | semmle.label | 5 | -| tst.ts:500:13:500:38 | [ArrowFunctionExpr] s => ty ... string" | tst.ts:500:18:500:38 | [BinaryExpr] typeof ... string" | semmle.order | 5 | -| tst.ts:500:18:500:25 | [UnaryExpr] typeof s | tst.ts:500:25:500:25 | [VarRef] s | semmle.label | 1 | -| tst.ts:500:18:500:25 | [UnaryExpr] typeof s | tst.ts:500:25:500:25 | [VarRef] s | semmle.order | 1 | -| tst.ts:500:18:500:38 | [BinaryExpr] typeof ... string" | tst.ts:500:18:500:25 | [UnaryExpr] typeof s | semmle.label | 1 | -| tst.ts:500:18:500:38 | [BinaryExpr] typeof ... string" | tst.ts:500:18:500:25 | [UnaryExpr] typeof s | semmle.order | 1 | -| tst.ts:500:18:500:38 | [BinaryExpr] typeof ... string" | tst.ts:500:31:500:38 | [Literal] "string" | semmle.label | 2 | -| tst.ts:500:18:500:38 | [BinaryExpr] typeof ... string" | tst.ts:500:31:500:38 | [Literal] "string" | semmle.order | 2 | -| tst.ts:502:3:504:3 | [ForOfStmt] for (co ... 5.4 } | tst.ts:502:8:502:16 | [DeclStmt] const str = ... | semmle.label | 1 | -| tst.ts:502:3:504:3 | [ForOfStmt] for (co ... 5.4 } | tst.ts:502:8:502:16 | [DeclStmt] const str = ... | semmle.order | 1 | -| tst.ts:502:3:504:3 | [ForOfStmt] for (co ... 5.4 } | tst.ts:502:21:502:27 | [VarRef] strings | semmle.label | 2 | -| tst.ts:502:3:504:3 | [ForOfStmt] for (co ... 5.4 } | tst.ts:502:21:502:27 | [VarRef] strings | semmle.order | 2 | -| tst.ts:502:3:504:3 | [ForOfStmt] for (co ... 5.4 } | tst.ts:502:30:504:3 | [BlockStmt] { s ... 5.4 } | semmle.label | 3 | -| tst.ts:502:3:504:3 | [ForOfStmt] for (co ... 5.4 } | tst.ts:502:30:504:3 | [BlockStmt] { s ... 5.4 } | semmle.order | 3 | -| tst.ts:502:8:502:16 | [DeclStmt] const str = ... | tst.ts:502:14:502:16 | [VariableDeclarator] str | semmle.label | 1 | -| tst.ts:502:8:502:16 | [DeclStmt] const str = ... | tst.ts:502:14:502:16 | [VariableDeclarator] str | semmle.order | 1 | -| tst.ts:502:14:502:16 | [VariableDeclarator] str | tst.ts:502:14:502:16 | [VarDecl] str | semmle.label | 1 | -| tst.ts:502:14:502:16 | [VariableDeclarator] str | tst.ts:502:14:502:16 | [VarDecl] str | semmle.order | 1 | -| tst.ts:502:30:504:3 | [BlockStmt] { s ... 5.4 } | tst.ts:503:5:503:22 | [ExprStmt] str.toLowerCase(); | semmle.label | 1 | -| tst.ts:502:30:504:3 | [BlockStmt] { s ... 5.4 } | tst.ts:503:5:503:22 | [ExprStmt] str.toLowerCase(); | semmle.order | 1 | -| tst.ts:503:5:503:19 | [DotExpr] str.toLowerCase | tst.ts:503:5:503:7 | [VarRef] str | semmle.label | 1 | -| tst.ts:503:5:503:19 | [DotExpr] str.toLowerCase | tst.ts:503:5:503:7 | [VarRef] str | semmle.order | 1 | -| tst.ts:503:5:503:19 | [DotExpr] str.toLowerCase | tst.ts:503:9:503:19 | [Label] toLowerCase | semmle.label | 2 | -| tst.ts:503:5:503:19 | [DotExpr] str.toLowerCase | tst.ts:503:9:503:19 | [Label] toLowerCase | semmle.order | 2 | -| tst.ts:503:5:503:21 | [MethodCallExpr] str.toLowerCase() | tst.ts:503:5:503:19 | [DotExpr] str.toLowerCase | semmle.label | 0 | -| tst.ts:503:5:503:21 | [MethodCallExpr] str.toLowerCase() | tst.ts:503:5:503:19 | [DotExpr] str.toLowerCase | semmle.order | 0 | -| tst.ts:503:5:503:22 | [ExprStmt] str.toLowerCase(); | tst.ts:503:5:503:21 | [MethodCallExpr] str.toLowerCase() | semmle.label | 1 | -| tst.ts:503:5:503:22 | [ExprStmt] str.toLowerCase(); | tst.ts:503:5:503:21 | [MethodCallExpr] str.toLowerCase() | semmle.order | 1 | -| tst.ts:506:3:510:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| tst.ts:506:3:510:3 | [FunctionDeclStmt] functio ... } } | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| tst.ts:506:3:510:3 | [FunctionDeclStmt] functio ... } } | tst.ts:506:12:506:13 | [VarDecl] f1 | semmle.label | 0 | -| tst.ts:506:3:510:3 | [FunctionDeclStmt] functio ... } } | tst.ts:506:12:506:13 | [VarDecl] f1 | semmle.order | 0 | -| tst.ts:506:3:510:3 | [FunctionDeclStmt] functio ... } } | tst.ts:506:58:510:3 | [BlockStmt] { i ... } } | semmle.label | 5 | -| tst.ts:506:3:510:3 | [FunctionDeclStmt] functio ... } } | tst.ts:506:58:510:3 | [BlockStmt] { i ... } } | semmle.order | 5 | -| tst.ts:506:15:506:17 | [SimpleParameter] obj | tst.ts:506:20:506:42 | [GenericTypeExpr] Record< ... nknown> | semmle.label | -2 | -| tst.ts:506:15:506:17 | [SimpleParameter] obj | tst.ts:506:20:506:42 | [GenericTypeExpr] Record< ... nknown> | semmle.order | -2 | -| tst.ts:506:20:506:42 | [GenericTypeExpr] Record< ... nknown> | tst.ts:506:20:506:25 | [LocalTypeAccess] Record | semmle.label | 1 | -| tst.ts:506:20:506:42 | [GenericTypeExpr] Record< ... nknown> | tst.ts:506:20:506:25 | [LocalTypeAccess] Record | semmle.order | 1 | -| tst.ts:506:20:506:42 | [GenericTypeExpr] Record< ... nknown> | tst.ts:506:27:506:32 | [KeywordTypeExpr] string | semmle.label | 2 | -| tst.ts:506:20:506:42 | [GenericTypeExpr] Record< ... nknown> | tst.ts:506:27:506:32 | [KeywordTypeExpr] string | semmle.order | 2 | -| tst.ts:506:20:506:42 | [GenericTypeExpr] Record< ... nknown> | tst.ts:506:35:506:41 | [KeywordTypeExpr] unknown | semmle.label | 3 | -| tst.ts:506:20:506:42 | [GenericTypeExpr] Record< ... nknown> | tst.ts:506:35:506:41 | [KeywordTypeExpr] unknown | semmle.order | 3 | -| tst.ts:506:45:506:47 | [SimpleParameter] key | tst.ts:506:50:506:55 | [KeywordTypeExpr] string | semmle.label | -2 | -| tst.ts:506:45:506:47 | [SimpleParameter] key | tst.ts:506:50:506:55 | [KeywordTypeExpr] string | semmle.order | -2 | -| tst.ts:506:58:510:3 | [BlockStmt] { i ... } } | tst.ts:507:5:509:5 | [IfStmt] if (typ ... r } | semmle.label | 1 | -| tst.ts:506:58:510:3 | [BlockStmt] { i ... } } | tst.ts:507:5:509:5 | [IfStmt] if (typ ... r } | semmle.order | 1 | -| tst.ts:507:5:509:5 | [IfStmt] if (typ ... r } | tst.ts:507:9:507:36 | [BinaryExpr] typeof ... string" | semmle.label | 1 | -| tst.ts:507:5:509:5 | [IfStmt] if (typ ... r } | tst.ts:507:9:507:36 | [BinaryExpr] typeof ... string" | semmle.order | 1 | -| tst.ts:507:5:509:5 | [IfStmt] if (typ ... r } | tst.ts:507:39:509:5 | [BlockStmt] { ... r } | semmle.label | 2 | -| tst.ts:507:5:509:5 | [IfStmt] if (typ ... r } | tst.ts:507:39:509:5 | [BlockStmt] { ... r } | semmle.order | 2 | -| tst.ts:507:9:507:23 | [UnaryExpr] typeof obj[key] | tst.ts:507:16:507:23 | [IndexExpr] obj[key] | semmle.label | 1 | -| tst.ts:507:9:507:23 | [UnaryExpr] typeof obj[key] | tst.ts:507:16:507:23 | [IndexExpr] obj[key] | semmle.order | 1 | -| tst.ts:507:9:507:36 | [BinaryExpr] typeof ... string" | tst.ts:507:9:507:23 | [UnaryExpr] typeof obj[key] | semmle.label | 1 | -| tst.ts:507:9:507:36 | [BinaryExpr] typeof ... string" | tst.ts:507:9:507:23 | [UnaryExpr] typeof obj[key] | semmle.order | 1 | -| tst.ts:507:9:507:36 | [BinaryExpr] typeof ... string" | tst.ts:507:29:507:36 | [Literal] "string" | semmle.label | 2 | -| tst.ts:507:9:507:36 | [BinaryExpr] typeof ... string" | tst.ts:507:29:507:36 | [Literal] "string" | semmle.order | 2 | -| tst.ts:507:16:507:23 | [IndexExpr] obj[key] | tst.ts:507:16:507:18 | [VarRef] obj | semmle.label | 1 | -| tst.ts:507:16:507:23 | [IndexExpr] obj[key] | tst.ts:507:16:507:18 | [VarRef] obj | semmle.order | 1 | -| tst.ts:507:16:507:23 | [IndexExpr] obj[key] | tst.ts:507:20:507:22 | [VarRef] key | semmle.label | 2 | -| tst.ts:507:16:507:23 | [IndexExpr] obj[key] | tst.ts:507:20:507:22 | [VarRef] key | semmle.order | 2 | -| tst.ts:507:39:509:5 | [BlockStmt] { ... r } | tst.ts:508:7:508:39 | [DeclStmt] var str = ... | semmle.label | 1 | -| tst.ts:507:39:509:5 | [BlockStmt] { ... r } | tst.ts:508:7:508:39 | [DeclStmt] var str = ... | semmle.order | 1 | -| tst.ts:508:7:508:39 | [DeclStmt] var str = ... | tst.ts:508:11:508:38 | [VariableDeclarator] str = o ... rCase() | semmle.label | 1 | -| tst.ts:508:7:508:39 | [DeclStmt] var str = ... | tst.ts:508:11:508:38 | [VariableDeclarator] str = o ... rCase() | semmle.order | 1 | -| tst.ts:508:11:508:38 | [VariableDeclarator] str = o ... rCase() | tst.ts:508:11:508:13 | [VarDecl] str | semmle.label | 1 | -| tst.ts:508:11:508:38 | [VariableDeclarator] str = o ... rCase() | tst.ts:508:11:508:13 | [VarDecl] str | semmle.order | 1 | -| tst.ts:508:11:508:38 | [VariableDeclarator] str = o ... rCase() | tst.ts:508:17:508:38 | [MethodCallExpr] obj[key ... rCase() | semmle.label | 2 | -| tst.ts:508:11:508:38 | [VariableDeclarator] str = o ... rCase() | tst.ts:508:17:508:38 | [MethodCallExpr] obj[key ... rCase() | semmle.order | 2 | -| tst.ts:508:17:508:24 | [IndexExpr] obj[key] | tst.ts:508:17:508:19 | [VarRef] obj | semmle.label | 1 | -| tst.ts:508:17:508:24 | [IndexExpr] obj[key] | tst.ts:508:17:508:19 | [VarRef] obj | semmle.order | 1 | -| tst.ts:508:17:508:24 | [IndexExpr] obj[key] | tst.ts:508:21:508:23 | [VarRef] key | semmle.label | 2 | -| tst.ts:508:17:508:24 | [IndexExpr] obj[key] | tst.ts:508:21:508:23 | [VarRef] key | semmle.order | 2 | -| tst.ts:508:17:508:36 | [DotExpr] obj[key].toUpperCase | tst.ts:508:17:508:24 | [IndexExpr] obj[key] | semmle.label | 1 | -| tst.ts:508:17:508:36 | [DotExpr] obj[key].toUpperCase | tst.ts:508:17:508:24 | [IndexExpr] obj[key] | semmle.order | 1 | -| tst.ts:508:17:508:36 | [DotExpr] obj[key].toUpperCase | tst.ts:508:26:508:36 | [Label] toUpperCase | semmle.label | 2 | -| tst.ts:508:17:508:36 | [DotExpr] obj[key].toUpperCase | tst.ts:508:26:508:36 | [Label] toUpperCase | semmle.order | 2 | -| tst.ts:508:17:508:38 | [MethodCallExpr] obj[key ... rCase() | tst.ts:508:17:508:36 | [DotExpr] obj[key].toUpperCase | semmle.label | 0 | -| tst.ts:508:17:508:38 | [MethodCallExpr] obj[key ... rCase() | tst.ts:508:17:508:36 | [DotExpr] obj[key].toUpperCase | semmle.order | 0 | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | tst.ts:513:11:513:14 | [VarDecl] TS57 | semmle.label | 1 | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | tst.ts:513:11:513:14 | [VarDecl] TS57 | semmle.order | 1 | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | tst.ts:514:3:514:26 | [DeclStmt] const a = ... | semmle.label | 2 | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | tst.ts:514:3:514:26 | [DeclStmt] const a = ... | semmle.order | 2 | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | tst.ts:515:3:517:3 | [ExportDeclaration] export ... }; } | semmle.label | 3 | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | tst.ts:515:3:517:3 | [ExportDeclaration] export ... }; } | semmle.order | 3 | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | tst.ts:519:3:519:32 | [DeclStmt] const e1 = ... | semmle.label | 4 | -| tst.ts:513:1:520:1 | [NamespaceDeclaration] namespa ... type. } | tst.ts:519:3:519:32 | [DeclStmt] const e1 = ... | semmle.order | 4 | -| tst.ts:514:3:514:26 | [DeclStmt] const a = ... | tst.ts:514:17:514:25 | [VariableDeclarator] a: symbol | semmle.label | 1 | -| tst.ts:514:3:514:26 | [DeclStmt] const a = ... | tst.ts:514:17:514:25 | [VariableDeclarator] a: symbol | semmle.order | 1 | -| tst.ts:514:17:514:25 | [VariableDeclarator] a: symbol | tst.ts:514:17:514:17 | [VarDecl] a | semmle.label | 1 | -| tst.ts:514:17:514:25 | [VariableDeclarator] a: symbol | tst.ts:514:17:514:17 | [VarDecl] a | semmle.order | 1 | -| tst.ts:514:17:514:25 | [VariableDeclarator] a: symbol | tst.ts:514:20:514:25 | [KeywordTypeExpr] symbol | semmle.label | 2 | -| tst.ts:514:17:514:25 | [VariableDeclarator] a: symbol | tst.ts:514:20:514:25 | [KeywordTypeExpr] symbol | semmle.order | 2 | -| tst.ts:515:3:517:3 | [ExportDeclaration] export ... }; } | tst.ts:515:10:517:3 | [ClassDefinition,TypeDefinition] class A ... }; } | semmle.label | 1 | -| tst.ts:515:3:517:3 | [ExportDeclaration] export ... }; } | tst.ts:515:10:517:3 | [ClassDefinition,TypeDefinition] class A ... }; } | semmle.order | 1 | -| tst.ts:515:10:517:3 | [ClassDefinition,TypeDefinition] class A ... }; } | tst.ts:515:16:515:16 | [VarDecl] A | semmle.label | 1 | -| tst.ts:515:10:517:3 | [ClassDefinition,TypeDefinition] class A ... }; } | tst.ts:515:16:515:16 | [VarDecl] A | semmle.order | 1 | -| tst.ts:515:10:517:3 | [ClassDefinition,TypeDefinition] class A ... }; } | tst.ts:515:18:515:17 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | 2 | -| tst.ts:515:10:517:3 | [ClassDefinition,TypeDefinition] class A ... }; } | tst.ts:515:18:515:17 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.order | 2 | -| tst.ts:515:10:517:3 | [ClassDefinition,TypeDefinition] class A ... }; } | tst.ts:516:7:516:24 | [ClassInitializedMember,MethodDefinition] [a]() { return 1 } | semmle.label | 3 | -| tst.ts:515:10:517:3 | [ClassDefinition,TypeDefinition] class A ... }; } | tst.ts:516:7:516:24 | [ClassInitializedMember,MethodDefinition] [a]() { return 1 } | semmle.order | 3 | -| tst.ts:515:18:515:17 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:515:18:515:17 | [FunctionExpr] () {} | semmle.label | 2 | -| tst.ts:515:18:515:17 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:515:18:515:17 | [FunctionExpr] () {} | semmle.order | 2 | -| tst.ts:515:18:515:17 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:515:18:515:17 | [Label] constructor | semmle.label | 1 | -| tst.ts:515:18:515:17 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | tst.ts:515:18:515:17 | [Label] constructor | semmle.order | 1 | -| tst.ts:515:18:515:17 | [FunctionExpr] () {} | tst.ts:515:18:515:17 | [BlockStmt] {} | semmle.label | 5 | -| tst.ts:515:18:515:17 | [FunctionExpr] () {} | tst.ts:515:18:515:17 | [BlockStmt] {} | semmle.order | 5 | -| tst.ts:516:7:516:24 | [ClassInitializedMember,MethodDefinition] [a]() { return 1 } | tst.ts:516:7:516:24 | [FunctionExpr] [a]() { return 1 } | semmle.label | 1 | -| tst.ts:516:7:516:24 | [ClassInitializedMember,MethodDefinition] [a]() { return 1 } | tst.ts:516:7:516:24 | [FunctionExpr] [a]() { return 1 } | semmle.order | 1 | -| tst.ts:516:7:516:24 | [ClassInitializedMember,MethodDefinition] [a]() { return 1 } | tst.ts:516:8:516:8 | [VarRef] a | semmle.label | 2 | -| tst.ts:516:7:516:24 | [ClassInitializedMember,MethodDefinition] [a]() { return 1 } | tst.ts:516:8:516:8 | [VarRef] a | semmle.order | 2 | -| tst.ts:516:7:516:24 | [FunctionExpr] [a]() { return 1 } | tst.ts:516:13:516:24 | [BlockStmt] { return 1 } | semmle.label | 5 | -| tst.ts:516:7:516:24 | [FunctionExpr] [a]() { return 1 } | tst.ts:516:13:516:24 | [BlockStmt] { return 1 } | semmle.order | 5 | -| tst.ts:516:13:516:24 | [BlockStmt] { return 1 } | tst.ts:516:15:516:22 | [ReturnStmt] return 1 | semmle.label | 1 | -| tst.ts:516:13:516:24 | [BlockStmt] { return 1 } | tst.ts:516:15:516:22 | [ReturnStmt] return 1 | semmle.order | 1 | -| tst.ts:516:15:516:22 | [ReturnStmt] return 1 | tst.ts:516:22:516:22 | [Literal] 1 | semmle.label | 1 | -| tst.ts:516:15:516:22 | [ReturnStmt] return 1 | tst.ts:516:22:516:22 | [Literal] 1 | semmle.order | 1 | -| tst.ts:519:3:519:32 | [DeclStmt] const e1 = ... | tst.ts:519:17:519:31 | [VariableDeclarator] e1: A[typeof a] | semmle.label | 1 | -| tst.ts:519:3:519:32 | [DeclStmt] const e1 = ... | tst.ts:519:17:519:31 | [VariableDeclarator] e1: A[typeof a] | semmle.order | 1 | -| tst.ts:519:17:519:31 | [VariableDeclarator] e1: A[typeof a] | tst.ts:519:17:519:18 | [VarDecl] e1 | semmle.label | 1 | -| tst.ts:519:17:519:31 | [VariableDeclarator] e1: A[typeof a] | tst.ts:519:17:519:18 | [VarDecl] e1 | semmle.order | 1 | -| tst.ts:519:17:519:31 | [VariableDeclarator] e1: A[typeof a] | tst.ts:519:21:519:31 | [IndexedAccessTypeExpr] A[typeof a] | semmle.label | 2 | -| tst.ts:519:17:519:31 | [VariableDeclarator] e1: A[typeof a] | tst.ts:519:21:519:31 | [IndexedAccessTypeExpr] A[typeof a] | semmle.order | 2 | -| tst.ts:519:21:519:31 | [IndexedAccessTypeExpr] A[typeof a] | tst.ts:519:21:519:21 | [LocalTypeAccess] A | semmle.label | 1 | -| tst.ts:519:21:519:31 | [IndexedAccessTypeExpr] A[typeof a] | tst.ts:519:21:519:21 | [LocalTypeAccess] A | semmle.order | 1 | -| tst.ts:519:21:519:31 | [IndexedAccessTypeExpr] A[typeof a] | tst.ts:519:23:519:30 | [TypeofTypeExpr] typeof a | semmle.label | 2 | -| tst.ts:519:21:519:31 | [IndexedAccessTypeExpr] A[typeof a] | tst.ts:519:23:519:30 | [TypeofTypeExpr] typeof a | semmle.order | 2 | -| tst.ts:519:23:519:30 | [TypeofTypeExpr] typeof a | tst.ts:519:30:519:30 | [LocalVarTypeAccess] a | semmle.label | 1 | -| tst.ts:519:23:519:30 | [TypeofTypeExpr] typeof a | tst.ts:519:30:519:30 | [LocalVarTypeAccess] a | semmle.order | 1 | -| tstModuleCJS.cts:1:1:3:1 | [ExportDeclaration] export ... 'b'; } | tstModuleCJS.cts:1:8:3:1 | [FunctionDeclStmt] functio ... 'b'; } | semmle.label | 1 | -| tstModuleCJS.cts:1:1:3:1 | [ExportDeclaration] export ... 'b'; } | tstModuleCJS.cts:1:8:3:1 | [FunctionDeclStmt] functio ... 'b'; } | semmle.order | 1 | -| tstModuleCJS.cts:1:8:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleCJS.cts:1:17:1:28 | [VarDecl] tstModuleCJS | semmle.label | 0 | -| tstModuleCJS.cts:1:8:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleCJS.cts:1:17:1:28 | [VarDecl] tstModuleCJS | semmle.order | 0 | -| tstModuleCJS.cts:1:8:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleCJS.cts:1:33:1:41 | [UnionTypeExpr] 'a' \| 'b' | semmle.label | 4 | -| tstModuleCJS.cts:1:8:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleCJS.cts:1:33:1:41 | [UnionTypeExpr] 'a' \| 'b' | semmle.order | 4 | -| tstModuleCJS.cts:1:8:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleCJS.cts:1:43:3:1 | [BlockStmt] { r ... 'b'; } | semmle.label | 5 | -| tstModuleCJS.cts:1:8:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleCJS.cts:1:43:3:1 | [BlockStmt] { r ... 'b'; } | semmle.order | 5 | -| tstModuleCJS.cts:1:33:1:41 | [UnionTypeExpr] 'a' \| 'b' | tstModuleCJS.cts:1:33:1:35 | [LiteralTypeExpr] 'a' | semmle.label | 1 | -| tstModuleCJS.cts:1:33:1:41 | [UnionTypeExpr] 'a' \| 'b' | tstModuleCJS.cts:1:33:1:35 | [LiteralTypeExpr] 'a' | semmle.order | 1 | -| tstModuleCJS.cts:1:33:1:41 | [UnionTypeExpr] 'a' \| 'b' | tstModuleCJS.cts:1:39:1:41 | [LiteralTypeExpr] 'b' | semmle.label | 2 | -| tstModuleCJS.cts:1:33:1:41 | [UnionTypeExpr] 'a' \| 'b' | tstModuleCJS.cts:1:39:1:41 | [LiteralTypeExpr] 'b' | semmle.order | 2 | -| tstModuleCJS.cts:1:43:3:1 | [BlockStmt] { r ... 'b'; } | tstModuleCJS.cts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | semmle.label | 1 | -| tstModuleCJS.cts:1:43:3:1 | [BlockStmt] { r ... 'b'; } | tstModuleCJS.cts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | semmle.order | 1 | -| tstModuleCJS.cts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | tstModuleCJS.cts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | semmle.label | 1 | -| tstModuleCJS.cts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | tstModuleCJS.cts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | semmle.order | 1 | -| tstModuleCJS.cts:2:12:2:22 | [DotExpr] Math.random | tstModuleCJS.cts:2:12:2:15 | [VarRef] Math | semmle.label | 1 | -| tstModuleCJS.cts:2:12:2:22 | [DotExpr] Math.random | tstModuleCJS.cts:2:12:2:15 | [VarRef] Math | semmle.order | 1 | -| tstModuleCJS.cts:2:12:2:22 | [DotExpr] Math.random | tstModuleCJS.cts:2:17:2:22 | [Label] random | semmle.label | 2 | -| tstModuleCJS.cts:2:12:2:22 | [DotExpr] Math.random | tstModuleCJS.cts:2:17:2:22 | [Label] random | semmle.order | 2 | -| tstModuleCJS.cts:2:12:2:24 | [MethodCallExpr] Math.random() | tstModuleCJS.cts:2:12:2:22 | [DotExpr] Math.random | semmle.label | 0 | -| tstModuleCJS.cts:2:12:2:24 | [MethodCallExpr] Math.random() | tstModuleCJS.cts:2:12:2:22 | [DotExpr] Math.random | semmle.order | 0 | -| tstModuleCJS.cts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | tstModuleCJS.cts:2:12:2:24 | [MethodCallExpr] Math.random() | semmle.label | 1 | -| tstModuleCJS.cts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | tstModuleCJS.cts:2:12:2:24 | [MethodCallExpr] Math.random() | semmle.order | 1 | -| tstModuleCJS.cts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | tstModuleCJS.cts:2:28:2:30 | [Literal] 0.5 | semmle.label | 2 | -| tstModuleCJS.cts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | tstModuleCJS.cts:2:28:2:30 | [Literal] 0.5 | semmle.order | 2 | -| tstModuleCJS.cts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleCJS.cts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | semmle.label | 1 | -| tstModuleCJS.cts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleCJS.cts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | semmle.order | 1 | -| tstModuleCJS.cts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleCJS.cts:2:34:2:36 | [Literal] 'a' | semmle.label | 2 | -| tstModuleCJS.cts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleCJS.cts:2:34:2:36 | [Literal] 'a' | semmle.order | 2 | -| tstModuleCJS.cts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleCJS.cts:2:40:2:42 | [Literal] 'b' | semmle.label | 3 | -| tstModuleCJS.cts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleCJS.cts:2:40:2:42 | [Literal] 'b' | semmle.order | 3 | -| tstModuleES.mts:1:1:3:1 | [ExportDeclaration] export ... 'b'; } | tstModuleES.mts:1:16:3:1 | [FunctionDeclStmt] functio ... 'b'; } | semmle.label | 1 | -| tstModuleES.mts:1:1:3:1 | [ExportDeclaration] export ... 'b'; } | tstModuleES.mts:1:16:3:1 | [FunctionDeclStmt] functio ... 'b'; } | semmle.order | 1 | -| tstModuleES.mts:1:16:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleES.mts:1:25:1:35 | [VarDecl] tstModuleES | semmle.label | 0 | -| tstModuleES.mts:1:16:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleES.mts:1:25:1:35 | [VarDecl] tstModuleES | semmle.order | 0 | -| tstModuleES.mts:1:16:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleES.mts:1:40:1:48 | [UnionTypeExpr] 'a' \| 'b' | semmle.label | 4 | -| tstModuleES.mts:1:16:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleES.mts:1:40:1:48 | [UnionTypeExpr] 'a' \| 'b' | semmle.order | 4 | -| tstModuleES.mts:1:16:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleES.mts:1:50:3:1 | [BlockStmt] { r ... 'b'; } | semmle.label | 5 | -| tstModuleES.mts:1:16:3:1 | [FunctionDeclStmt] functio ... 'b'; } | tstModuleES.mts:1:50:3:1 | [BlockStmt] { r ... 'b'; } | semmle.order | 5 | -| tstModuleES.mts:1:40:1:48 | [UnionTypeExpr] 'a' \| 'b' | tstModuleES.mts:1:40:1:42 | [LiteralTypeExpr] 'a' | semmle.label | 1 | -| tstModuleES.mts:1:40:1:48 | [UnionTypeExpr] 'a' \| 'b' | tstModuleES.mts:1:40:1:42 | [LiteralTypeExpr] 'a' | semmle.order | 1 | -| tstModuleES.mts:1:40:1:48 | [UnionTypeExpr] 'a' \| 'b' | tstModuleES.mts:1:46:1:48 | [LiteralTypeExpr] 'b' | semmle.label | 2 | -| tstModuleES.mts:1:40:1:48 | [UnionTypeExpr] 'a' \| 'b' | tstModuleES.mts:1:46:1:48 | [LiteralTypeExpr] 'b' | semmle.order | 2 | -| tstModuleES.mts:1:50:3:1 | [BlockStmt] { r ... 'b'; } | tstModuleES.mts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | semmle.label | 1 | -| tstModuleES.mts:1:50:3:1 | [BlockStmt] { r ... 'b'; } | tstModuleES.mts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | semmle.order | 1 | -| tstModuleES.mts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | tstModuleES.mts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | semmle.label | 1 | -| tstModuleES.mts:2:5:2:43 | [ReturnStmt] return ... : 'b'; | tstModuleES.mts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | semmle.order | 1 | -| tstModuleES.mts:2:12:2:22 | [DotExpr] Math.random | tstModuleES.mts:2:12:2:15 | [VarRef] Math | semmle.label | 1 | -| tstModuleES.mts:2:12:2:22 | [DotExpr] Math.random | tstModuleES.mts:2:12:2:15 | [VarRef] Math | semmle.order | 1 | -| tstModuleES.mts:2:12:2:22 | [DotExpr] Math.random | tstModuleES.mts:2:17:2:22 | [Label] random | semmle.label | 2 | -| tstModuleES.mts:2:12:2:22 | [DotExpr] Math.random | tstModuleES.mts:2:17:2:22 | [Label] random | semmle.order | 2 | -| tstModuleES.mts:2:12:2:24 | [MethodCallExpr] Math.random() | tstModuleES.mts:2:12:2:22 | [DotExpr] Math.random | semmle.label | 0 | -| tstModuleES.mts:2:12:2:24 | [MethodCallExpr] Math.random() | tstModuleES.mts:2:12:2:22 | [DotExpr] Math.random | semmle.order | 0 | -| tstModuleES.mts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | tstModuleES.mts:2:12:2:24 | [MethodCallExpr] Math.random() | semmle.label | 1 | -| tstModuleES.mts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | tstModuleES.mts:2:12:2:24 | [MethodCallExpr] Math.random() | semmle.order | 1 | -| tstModuleES.mts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | tstModuleES.mts:2:28:2:30 | [Literal] 0.5 | semmle.label | 2 | -| tstModuleES.mts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | tstModuleES.mts:2:28:2:30 | [Literal] 0.5 | semmle.order | 2 | -| tstModuleES.mts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleES.mts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | semmle.label | 1 | -| tstModuleES.mts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleES.mts:2:12:2:30 | [BinaryExpr] Math.random() > 0.5 | semmle.order | 1 | -| tstModuleES.mts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleES.mts:2:34:2:36 | [Literal] 'a' | semmle.label | 2 | -| tstModuleES.mts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleES.mts:2:34:2:36 | [Literal] 'a' | semmle.order | 2 | -| tstModuleES.mts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleES.mts:2:40:2:42 | [Literal] 'b' | semmle.label | 3 | -| tstModuleES.mts:2:12:2:42 | [ConditionalExpr] Math.ra ... ' : 'b' | tstModuleES.mts:2:40:2:42 | [Literal] 'b' | semmle.order | 3 | -| tstSuffixA.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | tstSuffixA.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | semmle.label | 1 | -| tstSuffixA.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | tstSuffixA.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | semmle.order | 1 | -| tstSuffixA.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixA.ts:1:17:1:28 | [VarDecl] resolvedFile | semmle.label | 0 | -| tstSuffixA.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixA.ts:1:17:1:28 | [VarDecl] resolvedFile | semmle.order | 0 | -| tstSuffixA.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixA.ts:1:33:1:47 | [LiteralTypeExpr] 'tstSuffixA.ts' | semmle.label | 4 | -| tstSuffixA.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixA.ts:1:33:1:47 | [LiteralTypeExpr] 'tstSuffixA.ts' | semmle.order | 4 | -| tstSuffixA.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixA.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | semmle.label | 5 | -| tstSuffixA.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixA.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | semmle.order | 5 | -| tstSuffixA.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | tstSuffixA.ts:2:5:2:27 | [ReturnStmt] return ... xA.ts'; | semmle.label | 1 | -| tstSuffixA.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | tstSuffixA.ts:2:5:2:27 | [ReturnStmt] return ... xA.ts'; | semmle.order | 1 | -| tstSuffixA.ts:2:5:2:27 | [ReturnStmt] return ... xA.ts'; | tstSuffixA.ts:2:12:2:26 | [Literal] 'tstSuffixA.ts' | semmle.label | 1 | -| tstSuffixA.ts:2:5:2:27 | [ReturnStmt] return ... xA.ts'; | tstSuffixA.ts:2:12:2:26 | [Literal] 'tstSuffixA.ts' | semmle.order | 1 | -| tstSuffixB.ios.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | tstSuffixB.ios.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | semmle.label | 1 | -| tstSuffixB.ios.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | tstSuffixB.ios.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | semmle.order | 1 | -| tstSuffixB.ios.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ios.ts:1:17:1:28 | [VarDecl] resolvedFile | semmle.label | 0 | -| tstSuffixB.ios.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ios.ts:1:17:1:28 | [VarDecl] resolvedFile | semmle.order | 0 | -| tstSuffixB.ios.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ios.ts:1:33:1:51 | [LiteralTypeExpr] 'tstSuffixB.ios.ts' | semmle.label | 4 | -| tstSuffixB.ios.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ios.ts:1:33:1:51 | [LiteralTypeExpr] 'tstSuffixB.ios.ts' | semmle.order | 4 | -| tstSuffixB.ios.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ios.ts:1:53:3:1 | [BlockStmt] { r ... .ts'; } | semmle.label | 5 | -| tstSuffixB.ios.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ios.ts:1:53:3:1 | [BlockStmt] { r ... .ts'; } | semmle.order | 5 | -| tstSuffixB.ios.ts:1:53:3:1 | [BlockStmt] { r ... .ts'; } | tstSuffixB.ios.ts:2:5:2:31 | [ReturnStmt] return ... os.ts'; | semmle.label | 1 | -| tstSuffixB.ios.ts:1:53:3:1 | [BlockStmt] { r ... .ts'; } | tstSuffixB.ios.ts:2:5:2:31 | [ReturnStmt] return ... os.ts'; | semmle.order | 1 | -| tstSuffixB.ios.ts:2:5:2:31 | [ReturnStmt] return ... os.ts'; | tstSuffixB.ios.ts:2:12:2:30 | [Literal] 'tstSuffixB.ios.ts' | semmle.label | 1 | -| tstSuffixB.ios.ts:2:5:2:31 | [ReturnStmt] return ... os.ts'; | tstSuffixB.ios.ts:2:12:2:30 | [Literal] 'tstSuffixB.ios.ts' | semmle.order | 1 | -| tstSuffixB.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | tstSuffixB.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | semmle.label | 1 | -| tstSuffixB.ts:1:1:3:1 | [ExportDeclaration] export ... .ts'; } | tstSuffixB.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | semmle.order | 1 | -| tstSuffixB.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ts:1:17:1:28 | [VarDecl] resolvedFile | semmle.label | 0 | -| tstSuffixB.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ts:1:17:1:28 | [VarDecl] resolvedFile | semmle.order | 0 | -| tstSuffixB.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ts:1:33:1:47 | [LiteralTypeExpr] 'tstSuffixB.ts' | semmle.label | 4 | -| tstSuffixB.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ts:1:33:1:47 | [LiteralTypeExpr] 'tstSuffixB.ts' | semmle.order | 4 | -| tstSuffixB.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | semmle.label | 5 | -| tstSuffixB.ts:1:8:3:1 | [FunctionDeclStmt] functio ... .ts'; } | tstSuffixB.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | semmle.order | 5 | -| tstSuffixB.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | tstSuffixB.ts:2:5:2:27 | [ReturnStmt] return ... xB.ts'; | semmle.label | 1 | -| tstSuffixB.ts:1:49:3:1 | [BlockStmt] { r ... .ts'; } | tstSuffixB.ts:2:5:2:27 | [ReturnStmt] return ... xB.ts'; | semmle.order | 1 | -| tstSuffixB.ts:2:5:2:27 | [ReturnStmt] return ... xB.ts'; | tstSuffixB.ts:2:12:2:26 | [Literal] 'tstSuffixB.ts' | semmle.label | 1 | -| tstSuffixB.ts:2:5:2:27 | [ReturnStmt] return ... xB.ts'; | tstSuffixB.ts:2:12:2:26 | [Literal] 'tstSuffixB.ts' | semmle.order | 1 | -| type_alias.ts:1:1:1:17 | [TypeAliasDeclaration,TypeDefinition] type B = boolean; | type_alias.ts:1:6:1:6 | [Identifier] B | semmle.label | 1 | -| type_alias.ts:1:1:1:17 | [TypeAliasDeclaration,TypeDefinition] type B = boolean; | type_alias.ts:1:6:1:6 | [Identifier] B | semmle.order | 1 | -| type_alias.ts:1:1:1:17 | [TypeAliasDeclaration,TypeDefinition] type B = boolean; | type_alias.ts:1:10:1:16 | [KeywordTypeExpr] boolean | semmle.label | 2 | -| type_alias.ts:1:1:1:17 | [TypeAliasDeclaration,TypeDefinition] type B = boolean; | type_alias.ts:1:10:1:16 | [KeywordTypeExpr] boolean | semmle.order | 2 | -| type_alias.ts:3:1:3:9 | [DeclStmt] var b = ... | type_alias.ts:3:5:3:8 | [VariableDeclarator] b: B | semmle.label | 1 | -| type_alias.ts:3:1:3:9 | [DeclStmt] var b = ... | type_alias.ts:3:5:3:8 | [VariableDeclarator] b: B | semmle.order | 1 | -| type_alias.ts:3:5:3:8 | [VariableDeclarator] b: B | type_alias.ts:3:5:3:5 | [VarDecl] b | semmle.label | 1 | -| type_alias.ts:3:5:3:8 | [VariableDeclarator] b: B | type_alias.ts:3:5:3:5 | [VarDecl] b | semmle.order | 1 | -| type_alias.ts:3:5:3:8 | [VariableDeclarator] b: B | type_alias.ts:3:8:3:8 | [LocalTypeAccess] B | semmle.label | 2 | -| type_alias.ts:3:5:3:8 | [VariableDeclarator] b: B | type_alias.ts:3:8:3:8 | [LocalTypeAccess] B | semmle.order | 2 | -| type_alias.ts:5:1:5:50 | [TypeAliasDeclaration,TypeDefinition] type Va ... ay>; | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| type_alias.ts:5:1:5:50 | [TypeAliasDeclaration,TypeDefinition] type Va ... ay>; | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| type_alias.ts:5:1:5:50 | [TypeAliasDeclaration,TypeDefinition] type Va ... ay>; | type_alias.ts:5:6:5:17 | [Identifier] ValueOrArray | semmle.label | 1 | -| type_alias.ts:5:1:5:50 | [TypeAliasDeclaration,TypeDefinition] type Va ... ay>; | type_alias.ts:5:6:5:17 | [Identifier] ValueOrArray | semmle.order | 1 | -| type_alias.ts:5:1:5:50 | [TypeAliasDeclaration,TypeDefinition] type Va ... ay>; | type_alias.ts:5:24:5:49 | [UnionTypeExpr] T \| Arr ... ray> | semmle.label | 3 | -| type_alias.ts:5:1:5:50 | [TypeAliasDeclaration,TypeDefinition] type Va ... ay>; | type_alias.ts:5:24:5:49 | [UnionTypeExpr] T \| Arr ... ray> | semmle.order | 3 | -| type_alias.ts:5:19:5:19 | [TypeParameter] T | type_alias.ts:5:19:5:19 | [Identifier] T | semmle.label | 1 | -| type_alias.ts:5:19:5:19 | [TypeParameter] T | type_alias.ts:5:19:5:19 | [Identifier] T | semmle.order | 1 | -| type_alias.ts:5:24:5:49 | [UnionTypeExpr] T \| Arr ... ray> | type_alias.ts:5:24:5:24 | [LocalTypeAccess] T | semmle.label | 1 | -| type_alias.ts:5:24:5:49 | [UnionTypeExpr] T \| Arr ... ray> | type_alias.ts:5:24:5:24 | [LocalTypeAccess] T | semmle.order | 1 | -| type_alias.ts:5:24:5:49 | [UnionTypeExpr] T \| Arr ... ray> | type_alias.ts:5:28:5:49 | [GenericTypeExpr] Array> | semmle.label | 2 | -| type_alias.ts:5:24:5:49 | [UnionTypeExpr] T \| Arr ... ray> | type_alias.ts:5:28:5:49 | [GenericTypeExpr] Array> | semmle.order | 2 | -| type_alias.ts:5:28:5:49 | [GenericTypeExpr] Array> | type_alias.ts:5:28:5:32 | [LocalTypeAccess] Array | semmle.label | 1 | -| type_alias.ts:5:28:5:49 | [GenericTypeExpr] Array> | type_alias.ts:5:28:5:32 | [LocalTypeAccess] Array | semmle.order | 1 | -| type_alias.ts:5:28:5:49 | [GenericTypeExpr] Array> | type_alias.ts:5:34:5:48 | [GenericTypeExpr] ValueOrArray | semmle.label | 2 | -| type_alias.ts:5:28:5:49 | [GenericTypeExpr] Array> | type_alias.ts:5:34:5:48 | [GenericTypeExpr] ValueOrArray | semmle.order | 2 | -| type_alias.ts:5:34:5:48 | [GenericTypeExpr] ValueOrArray | type_alias.ts:5:34:5:45 | [LocalTypeAccess] ValueOrArray | semmle.label | 1 | -| type_alias.ts:5:34:5:48 | [GenericTypeExpr] ValueOrArray | type_alias.ts:5:34:5:45 | [LocalTypeAccess] ValueOrArray | semmle.order | 1 | -| type_alias.ts:5:34:5:48 | [GenericTypeExpr] ValueOrArray | type_alias.ts:5:47:5:47 | [LocalTypeAccess] T | semmle.label | 2 | -| type_alias.ts:5:34:5:48 | [GenericTypeExpr] ValueOrArray | type_alias.ts:5:47:5:47 | [LocalTypeAccess] T | semmle.order | 2 | -| type_alias.ts:7:1:7:28 | [DeclStmt] var c = ... | type_alias.ts:7:5:7:27 | [VariableDeclarator] c: Valu ... number> | semmle.label | 1 | -| type_alias.ts:7:1:7:28 | [DeclStmt] var c = ... | type_alias.ts:7:5:7:27 | [VariableDeclarator] c: Valu ... number> | semmle.order | 1 | -| type_alias.ts:7:5:7:27 | [VariableDeclarator] c: Valu ... number> | type_alias.ts:7:5:7:5 | [VarDecl] c | semmle.label | 1 | -| type_alias.ts:7:5:7:27 | [VariableDeclarator] c: Valu ... number> | type_alias.ts:7:5:7:5 | [VarDecl] c | semmle.order | 1 | -| type_alias.ts:7:5:7:27 | [VariableDeclarator] c: Valu ... number> | type_alias.ts:7:8:7:27 | [GenericTypeExpr] ValueOrArray | semmle.label | 2 | -| type_alias.ts:7:5:7:27 | [VariableDeclarator] c: Valu ... number> | type_alias.ts:7:8:7:27 | [GenericTypeExpr] ValueOrArray | semmle.order | 2 | -| type_alias.ts:7:8:7:27 | [GenericTypeExpr] ValueOrArray | type_alias.ts:7:8:7:19 | [LocalTypeAccess] ValueOrArray | semmle.label | 1 | -| type_alias.ts:7:8:7:27 | [GenericTypeExpr] ValueOrArray | type_alias.ts:7:8:7:19 | [LocalTypeAccess] ValueOrArray | semmle.order | 1 | -| type_alias.ts:7:8:7:27 | [GenericTypeExpr] ValueOrArray | type_alias.ts:7:21:7:26 | [KeywordTypeExpr] number | semmle.label | 2 | -| type_alias.ts:7:8:7:27 | [GenericTypeExpr] ValueOrArray | type_alias.ts:7:21:7:26 | [KeywordTypeExpr] number | semmle.order | 2 | -| type_alias.ts:9:1:15:13 | [TypeAliasDeclaration,TypeDefinition] type Js ... Json[]; | type_alias.ts:9:6:9:9 | [Identifier] Json | semmle.label | 1 | -| type_alias.ts:9:1:15:13 | [TypeAliasDeclaration,TypeDefinition] type Js ... Json[]; | type_alias.ts:9:6:9:9 | [Identifier] Json | semmle.order | 1 | -| type_alias.ts:9:1:15:13 | [TypeAliasDeclaration,TypeDefinition] type Js ... Json[]; | type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | semmle.label | 2 | -| type_alias.ts:9:1:15:13 | [TypeAliasDeclaration,TypeDefinition] type Js ... Json[]; | type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | semmle.order | 2 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:10:7:10:12 | [KeywordTypeExpr] string | semmle.label | 1 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:10:7:10:12 | [KeywordTypeExpr] string | semmle.order | 1 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:11:7:11:12 | [KeywordTypeExpr] number | semmle.label | 2 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:11:7:11:12 | [KeywordTypeExpr] number | semmle.order | 2 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:12:7:12:13 | [KeywordTypeExpr] boolean | semmle.label | 3 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:12:7:12:13 | [KeywordTypeExpr] boolean | semmle.order | 3 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:13:7:13:10 | [KeywordTypeExpr] null | semmle.label | 4 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:13:7:13:10 | [KeywordTypeExpr] null | semmle.order | 4 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:14:7:14:34 | [InterfaceTypeExpr] { [prop ... Json } | semmle.label | 5 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:14:7:14:34 | [InterfaceTypeExpr] { [prop ... Json } | semmle.order | 5 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:15:7:15:12 | [ArrayTypeExpr] Json[] | semmle.label | 6 | -| type_alias.ts:10:5:15:12 | [UnionTypeExpr] \| strin ... Json[] | type_alias.ts:15:7:15:12 | [ArrayTypeExpr] Json[] | semmle.order | 6 | -| type_alias.ts:14:7:14:34 | [InterfaceTypeExpr] { [prop ... Json } | type_alias.ts:14:9:14:32 | [IndexSignature] [proper ... ]: Json | semmle.label | 1 | -| type_alias.ts:14:7:14:34 | [InterfaceTypeExpr] { [prop ... Json } | type_alias.ts:14:9:14:32 | [IndexSignature] [proper ... ]: Json | semmle.order | 1 | -| type_alias.ts:14:9:14:32 | [FunctionExpr] [proper ... ]: Json | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| type_alias.ts:14:9:14:32 | [FunctionExpr] [proper ... ]: Json | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| type_alias.ts:14:9:14:32 | [FunctionExpr] [proper ... ]: Json | type_alias.ts:14:29:14:32 | [LocalTypeAccess] Json | semmle.label | 4 | -| type_alias.ts:14:9:14:32 | [FunctionExpr] [proper ... ]: Json | type_alias.ts:14:29:14:32 | [LocalTypeAccess] Json | semmle.order | 4 | -| type_alias.ts:14:9:14:32 | [IndexSignature] [proper ... ]: Json | type_alias.ts:14:9:14:32 | [FunctionExpr] [proper ... ]: Json | semmle.label | 1 | -| type_alias.ts:14:9:14:32 | [IndexSignature] [proper ... ]: Json | type_alias.ts:14:9:14:32 | [FunctionExpr] [proper ... ]: Json | semmle.order | 1 | -| type_alias.ts:14:10:14:17 | [SimpleParameter] property | type_alias.ts:14:20:14:25 | [KeywordTypeExpr] string | semmle.label | -2 | -| type_alias.ts:14:10:14:17 | [SimpleParameter] property | type_alias.ts:14:20:14:25 | [KeywordTypeExpr] string | semmle.order | -2 | -| type_alias.ts:15:7:15:12 | [ArrayTypeExpr] Json[] | type_alias.ts:15:7:15:10 | [LocalTypeAccess] Json | semmle.label | 1 | -| type_alias.ts:15:7:15:12 | [ArrayTypeExpr] Json[] | type_alias.ts:15:7:15:10 | [LocalTypeAccess] Json | semmle.order | 1 | -| type_alias.ts:17:1:17:15 | [DeclStmt] var json = ... | type_alias.ts:17:5:17:14 | [VariableDeclarator] json: Json | semmle.label | 1 | -| type_alias.ts:17:1:17:15 | [DeclStmt] var json = ... | type_alias.ts:17:5:17:14 | [VariableDeclarator] json: Json | semmle.order | 1 | -| type_alias.ts:17:5:17:14 | [VariableDeclarator] json: Json | type_alias.ts:17:5:17:8 | [VarDecl] json | semmle.label | 1 | -| type_alias.ts:17:5:17:14 | [VariableDeclarator] json: Json | type_alias.ts:17:5:17:8 | [VarDecl] json | semmle.order | 1 | -| type_alias.ts:17:5:17:14 | [VariableDeclarator] json: Json | type_alias.ts:17:11:17:14 | [LocalTypeAccess] Json | semmle.label | 2 | -| type_alias.ts:17:5:17:14 | [VariableDeclarator] json: Json | type_alias.ts:17:11:17:14 | [LocalTypeAccess] Json | semmle.order | 2 | -| type_alias.ts:19:1:21:57 | [TypeAliasDeclaration,TypeDefinition] type Vi ... ode[]]; | type_alias.ts:19:6:19:16 | [Identifier] VirtualNode | semmle.label | 1 | -| type_alias.ts:19:1:21:57 | [TypeAliasDeclaration,TypeDefinition] type Vi ... ode[]]; | type_alias.ts:19:6:19:16 | [Identifier] VirtualNode | semmle.order | 1 | -| type_alias.ts:19:1:21:57 | [TypeAliasDeclaration,TypeDefinition] type Vi ... ode[]]; | type_alias.ts:20:5:21:56 | [UnionTypeExpr] \| strin ... Node[]] | semmle.label | 2 | -| type_alias.ts:19:1:21:57 | [TypeAliasDeclaration,TypeDefinition] type Vi ... ode[]]; | type_alias.ts:20:5:21:56 | [UnionTypeExpr] \| strin ... Node[]] | semmle.order | 2 | -| type_alias.ts:20:5:21:56 | [UnionTypeExpr] \| strin ... Node[]] | type_alias.ts:20:7:20:12 | [KeywordTypeExpr] string | semmle.label | 1 | -| type_alias.ts:20:5:21:56 | [UnionTypeExpr] \| strin ... Node[]] | type_alias.ts:20:7:20:12 | [KeywordTypeExpr] string | semmle.order | 1 | -| type_alias.ts:20:5:21:56 | [UnionTypeExpr] \| strin ... Node[]] | type_alias.ts:21:7:21:56 | [TupleTypeExpr] [string ... Node[]] | semmle.label | 2 | -| type_alias.ts:20:5:21:56 | [UnionTypeExpr] \| strin ... Node[]] | type_alias.ts:21:7:21:56 | [TupleTypeExpr] [string ... Node[]] | semmle.order | 2 | -| type_alias.ts:21:7:21:56 | [TupleTypeExpr] [string ... Node[]] | type_alias.ts:21:8:21:13 | [KeywordTypeExpr] string | semmle.label | 1 | -| type_alias.ts:21:7:21:56 | [TupleTypeExpr] [string ... Node[]] | type_alias.ts:21:8:21:13 | [KeywordTypeExpr] string | semmle.order | 1 | -| type_alias.ts:21:7:21:56 | [TupleTypeExpr] [string ... Node[]] | type_alias.ts:21:16:21:37 | [InterfaceTypeExpr] { [key: ... : any } | semmle.label | 2 | -| type_alias.ts:21:7:21:56 | [TupleTypeExpr] [string ... Node[]] | type_alias.ts:21:16:21:37 | [InterfaceTypeExpr] { [key: ... : any } | semmle.order | 2 | -| type_alias.ts:21:7:21:56 | [TupleTypeExpr] [string ... Node[]] | type_alias.ts:21:40:21:55 | [RestTypeExpr] ...VirtualNode[] | semmle.label | 3 | -| type_alias.ts:21:7:21:56 | [TupleTypeExpr] [string ... Node[]] | type_alias.ts:21:40:21:55 | [RestTypeExpr] ...VirtualNode[] | semmle.order | 3 | -| type_alias.ts:21:16:21:37 | [InterfaceTypeExpr] { [key: ... : any } | type_alias.ts:21:18:21:35 | [IndexSignature] [key: string]: any | semmle.label | 1 | -| type_alias.ts:21:16:21:37 | [InterfaceTypeExpr] { [key: ... : any } | type_alias.ts:21:18:21:35 | [IndexSignature] [key: string]: any | semmle.order | 1 | -| type_alias.ts:21:18:21:35 | [FunctionExpr] [key: string]: any | file://:0:0:0:0 | (Parameters) | semmle.label | 1 | -| type_alias.ts:21:18:21:35 | [FunctionExpr] [key: string]: any | file://:0:0:0:0 | (Parameters) | semmle.order | 1 | -| type_alias.ts:21:18:21:35 | [FunctionExpr] [key: string]: any | type_alias.ts:21:33:21:35 | [KeywordTypeExpr] any | semmle.label | 4 | -| type_alias.ts:21:18:21:35 | [FunctionExpr] [key: string]: any | type_alias.ts:21:33:21:35 | [KeywordTypeExpr] any | semmle.order | 4 | -| type_alias.ts:21:18:21:35 | [IndexSignature] [key: string]: any | type_alias.ts:21:18:21:35 | [FunctionExpr] [key: string]: any | semmle.label | 1 | -| type_alias.ts:21:18:21:35 | [IndexSignature] [key: string]: any | type_alias.ts:21:18:21:35 | [FunctionExpr] [key: string]: any | semmle.order | 1 | -| type_alias.ts:21:19:21:21 | [SimpleParameter] key | type_alias.ts:21:24:21:29 | [KeywordTypeExpr] string | semmle.label | -2 | -| type_alias.ts:21:19:21:21 | [SimpleParameter] key | type_alias.ts:21:24:21:29 | [KeywordTypeExpr] string | semmle.order | -2 | -| type_alias.ts:21:40:21:55 | [RestTypeExpr] ...VirtualNode[] | type_alias.ts:21:43:21:55 | [ArrayTypeExpr] VirtualNode[] | semmle.label | 1 | -| type_alias.ts:21:40:21:55 | [RestTypeExpr] ...VirtualNode[] | type_alias.ts:21:43:21:55 | [ArrayTypeExpr] VirtualNode[] | semmle.order | 1 | -| type_alias.ts:21:43:21:55 | [ArrayTypeExpr] VirtualNode[] | type_alias.ts:21:43:21:53 | [LocalTypeAccess] VirtualNode | semmle.label | 1 | -| type_alias.ts:21:43:21:55 | [ArrayTypeExpr] VirtualNode[] | type_alias.ts:21:43:21:53 | [LocalTypeAccess] VirtualNode | semmle.order | 1 | -| type_alias.ts:23:1:27:6 | [DeclStmt] const myNode = ... | type_alias.ts:23:7:27:5 | [VariableDeclarator] myNode: ... ] ] | semmle.label | 1 | -| type_alias.ts:23:1:27:6 | [DeclStmt] const myNode = ... | type_alias.ts:23:7:27:5 | [VariableDeclarator] myNode: ... ] ] | semmle.order | 1 | -| type_alias.ts:23:7:27:5 | [VariableDeclarator] myNode: ... ] ] | type_alias.ts:23:7:23:12 | [VarDecl] myNode | semmle.label | 1 | -| type_alias.ts:23:7:27:5 | [VariableDeclarator] myNode: ... ] ] | type_alias.ts:23:7:23:12 | [VarDecl] myNode | semmle.order | 1 | -| type_alias.ts:23:7:27:5 | [VariableDeclarator] myNode: ... ] ] | type_alias.ts:23:15:23:25 | [LocalTypeAccess] VirtualNode | semmle.label | 2 | -| type_alias.ts:23:7:27:5 | [VariableDeclarator] myNode: ... ] ] | type_alias.ts:23:15:23:25 | [LocalTypeAccess] VirtualNode | semmle.order | 2 | -| type_alias.ts:23:7:27:5 | [VariableDeclarator] myNode: ... ] ] | type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | semmle.label | 3 | -| type_alias.ts:23:7:27:5 | [VariableDeclarator] myNode: ... ] ] | type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | semmle.order | 3 | -| type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | type_alias.ts:24:6:24:10 | [Literal] "div" | semmle.label | 1 | -| type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | type_alias.ts:24:6:24:10 | [Literal] "div" | semmle.order | 1 | -| type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | type_alias.ts:24:13:24:28 | [ObjectExpr] {id: ...} | semmle.label | 2 | -| type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | type_alias.ts:24:13:24:28 | [ObjectExpr] {id: ...} | semmle.order | 2 | -| type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | type_alias.ts:25:9:25:61 | [ArrayExpr] ["div", ... child"] | semmle.label | 3 | -| type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | type_alias.ts:25:9:25:61 | [ArrayExpr] ["div", ... child"] | semmle.order | 3 | -| type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | type_alias.ts:26:9:26:63 | [ArrayExpr] ["div", ... child"] | semmle.label | 4 | -| type_alias.ts:24:5:27:5 | [ArrayExpr] ["div", ... ] ] | type_alias.ts:26:9:26:63 | [ArrayExpr] ["div", ... child"] | semmle.order | 4 | -| type_alias.ts:24:13:24:28 | [ObjectExpr] {id: ...} | type_alias.ts:24:15:24:26 | [Property] id: "parent" | semmle.label | 1 | -| type_alias.ts:24:13:24:28 | [ObjectExpr] {id: ...} | type_alias.ts:24:15:24:26 | [Property] id: "parent" | semmle.order | 1 | -| type_alias.ts:24:15:24:26 | [Property] id: "parent" | type_alias.ts:24:15:24:16 | [Label] id | semmle.label | 1 | -| type_alias.ts:24:15:24:26 | [Property] id: "parent" | type_alias.ts:24:15:24:16 | [Label] id | semmle.order | 1 | -| type_alias.ts:24:15:24:26 | [Property] id: "parent" | type_alias.ts:24:19:24:26 | [Literal] "parent" | semmle.label | 2 | -| type_alias.ts:24:15:24:26 | [Property] id: "parent" | type_alias.ts:24:19:24:26 | [Literal] "parent" | semmle.order | 2 | -| type_alias.ts:25:9:25:61 | [ArrayExpr] ["div", ... child"] | type_alias.ts:25:10:25:14 | [Literal] "div" | semmle.label | 1 | -| type_alias.ts:25:9:25:61 | [ArrayExpr] ["div", ... child"] | type_alias.ts:25:10:25:14 | [Literal] "div" | semmle.order | 1 | -| type_alias.ts:25:9:25:61 | [ArrayExpr] ["div", ... child"] | type_alias.ts:25:17:25:37 | [ObjectExpr] {id: ...} | semmle.label | 2 | -| type_alias.ts:25:9:25:61 | [ArrayExpr] ["div", ... child"] | type_alias.ts:25:17:25:37 | [ObjectExpr] {id: ...} | semmle.order | 2 | -| type_alias.ts:25:9:25:61 | [ArrayExpr] ["div", ... child"] | type_alias.ts:25:40:25:60 | [Literal] "I'm the first child" | semmle.label | 3 | -| type_alias.ts:25:9:25:61 | [ArrayExpr] ["div", ... child"] | type_alias.ts:25:40:25:60 | [Literal] "I'm the first child" | semmle.order | 3 | -| type_alias.ts:25:17:25:37 | [ObjectExpr] {id: ...} | type_alias.ts:25:19:25:35 | [Property] id: "first-child" | semmle.label | 1 | -| type_alias.ts:25:17:25:37 | [ObjectExpr] {id: ...} | type_alias.ts:25:19:25:35 | [Property] id: "first-child" | semmle.order | 1 | -| type_alias.ts:25:19:25:35 | [Property] id: "first-child" | type_alias.ts:25:19:25:20 | [Label] id | semmle.label | 1 | -| type_alias.ts:25:19:25:35 | [Property] id: "first-child" | type_alias.ts:25:19:25:20 | [Label] id | semmle.order | 1 | -| type_alias.ts:25:19:25:35 | [Property] id: "first-child" | type_alias.ts:25:23:25:35 | [Literal] "first-child" | semmle.label | 2 | -| type_alias.ts:25:19:25:35 | [Property] id: "first-child" | type_alias.ts:25:23:25:35 | [Literal] "first-child" | semmle.order | 2 | -| type_alias.ts:26:9:26:63 | [ArrayExpr] ["div", ... child"] | type_alias.ts:26:10:26:14 | [Literal] "div" | semmle.label | 1 | -| type_alias.ts:26:9:26:63 | [ArrayExpr] ["div", ... child"] | type_alias.ts:26:10:26:14 | [Literal] "div" | semmle.order | 1 | -| type_alias.ts:26:9:26:63 | [ArrayExpr] ["div", ... child"] | type_alias.ts:26:17:26:38 | [ObjectExpr] {id: ...} | semmle.label | 2 | -| type_alias.ts:26:9:26:63 | [ArrayExpr] ["div", ... child"] | type_alias.ts:26:17:26:38 | [ObjectExpr] {id: ...} | semmle.order | 2 | -| type_alias.ts:26:9:26:63 | [ArrayExpr] ["div", ... child"] | type_alias.ts:26:41:26:62 | [Literal] "I'm the second child" | semmle.label | 3 | -| type_alias.ts:26:9:26:63 | [ArrayExpr] ["div", ... child"] | type_alias.ts:26:41:26:62 | [Literal] "I'm the second child" | semmle.order | 3 | -| type_alias.ts:26:17:26:38 | [ObjectExpr] {id: ...} | type_alias.ts:26:19:26:36 | [Property] id: "second-child" | semmle.label | 1 | -| type_alias.ts:26:17:26:38 | [ObjectExpr] {id: ...} | type_alias.ts:26:19:26:36 | [Property] id: "second-child" | semmle.order | 1 | -| type_alias.ts:26:19:26:36 | [Property] id: "second-child" | type_alias.ts:26:19:26:20 | [Label] id | semmle.label | 1 | -| type_alias.ts:26:19:26:36 | [Property] id: "second-child" | type_alias.ts:26:19:26:20 | [Label] id | semmle.order | 1 | -| type_alias.ts:26:19:26:36 | [Property] id: "second-child" | type_alias.ts:26:23:26:36 | [Literal] "second-child" | semmle.label | 2 | -| type_alias.ts:26:19:26:36 | [Property] id: "second-child" | type_alias.ts:26:23:26:36 | [Literal] "second-child" | semmle.order | 2 | -| type_definition_objects.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | type_definition_objects.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.label | 1 | -| type_definition_objects.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | type_definition_objects.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.order | 1 | -| type_definition_objects.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | type_definition_objects.ts:1:24:1:32 | [Literal] "./dummy" | semmle.label | 2 | -| type_definition_objects.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | type_definition_objects.ts:1:24:1:32 | [Literal] "./dummy" | semmle.order | 2 | -| type_definition_objects.ts:1:8:1:17 | [ImportSpecifier] * as dummy | type_definition_objects.ts:1:13:1:17 | [VarDecl] dummy | semmle.label | 1 | -| type_definition_objects.ts:1:8:1:17 | [ImportSpecifier] * as dummy | type_definition_objects.ts:1:13:1:17 | [VarDecl] dummy | semmle.order | 1 | -| type_definition_objects.ts:3:1:3:17 | [ExportDeclaration] export class C {} | type_definition_objects.ts:3:8:3:17 | [ClassDefinition,TypeDefinition] class C {} | semmle.label | 1 | -| type_definition_objects.ts:3:1:3:17 | [ExportDeclaration] export class C {} | type_definition_objects.ts:3:8:3:17 | [ClassDefinition,TypeDefinition] class C {} | semmle.order | 1 | -| type_definition_objects.ts:3:8:3:17 | [ClassDefinition,TypeDefinition] class C {} | type_definition_objects.ts:3:14:3:14 | [VarDecl] C | semmle.label | 1 | -| type_definition_objects.ts:3:8:3:17 | [ClassDefinition,TypeDefinition] class C {} | type_definition_objects.ts:3:14:3:14 | [VarDecl] C | semmle.order | 1 | -| type_definition_objects.ts:3:8:3:17 | [ClassDefinition,TypeDefinition] class C {} | type_definition_objects.ts:3:16:3:15 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | 2 | -| type_definition_objects.ts:3:8:3:17 | [ClassDefinition,TypeDefinition] class C {} | type_definition_objects.ts:3:16:3:15 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.order | 2 | -| type_definition_objects.ts:3:16:3:15 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | type_definition_objects.ts:3:16:3:15 | [FunctionExpr] () {} | semmle.label | 2 | -| type_definition_objects.ts:3:16:3:15 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | type_definition_objects.ts:3:16:3:15 | [FunctionExpr] () {} | semmle.order | 2 | -| type_definition_objects.ts:3:16:3:15 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | type_definition_objects.ts:3:16:3:15 | [Label] constructor | semmle.label | 1 | -| type_definition_objects.ts:3:16:3:15 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | type_definition_objects.ts:3:16:3:15 | [Label] constructor | semmle.order | 1 | -| type_definition_objects.ts:3:16:3:15 | [FunctionExpr] () {} | type_definition_objects.ts:3:16:3:15 | [BlockStmt] {} | semmle.label | 5 | -| type_definition_objects.ts:3:16:3:15 | [FunctionExpr] () {} | type_definition_objects.ts:3:16:3:15 | [BlockStmt] {} | semmle.order | 5 | -| type_definition_objects.ts:4:1:4:17 | [DeclStmt] let classObj = ... | type_definition_objects.ts:4:5:4:16 | [VariableDeclarator] classObj = C | semmle.label | 1 | -| type_definition_objects.ts:4:1:4:17 | [DeclStmt] let classObj = ... | type_definition_objects.ts:4:5:4:16 | [VariableDeclarator] classObj = C | semmle.order | 1 | -| type_definition_objects.ts:4:5:4:16 | [VariableDeclarator] classObj = C | type_definition_objects.ts:4:5:4:12 | [VarDecl] classObj | semmle.label | 1 | -| type_definition_objects.ts:4:5:4:16 | [VariableDeclarator] classObj = C | type_definition_objects.ts:4:5:4:12 | [VarDecl] classObj | semmle.order | 1 | -| type_definition_objects.ts:4:5:4:16 | [VariableDeclarator] classObj = C | type_definition_objects.ts:4:16:4:16 | [VarRef] C | semmle.label | 2 | -| type_definition_objects.ts:4:5:4:16 | [VariableDeclarator] classObj = C | type_definition_objects.ts:4:16:4:16 | [VarRef] C | semmle.order | 2 | -| type_definition_objects.ts:6:1:6:16 | [ExportDeclaration] export enum E {} | type_definition_objects.ts:6:8:6:16 | [EnumDeclaration,TypeDefinition] enum E {} | semmle.label | 1 | -| type_definition_objects.ts:6:1:6:16 | [ExportDeclaration] export enum E {} | type_definition_objects.ts:6:8:6:16 | [EnumDeclaration,TypeDefinition] enum E {} | semmle.order | 1 | -| type_definition_objects.ts:6:8:6:16 | [EnumDeclaration,TypeDefinition] enum E {} | type_definition_objects.ts:6:13:6:13 | [VarDecl] E | semmle.label | 1 | -| type_definition_objects.ts:6:8:6:16 | [EnumDeclaration,TypeDefinition] enum E {} | type_definition_objects.ts:6:13:6:13 | [VarDecl] E | semmle.order | 1 | -| type_definition_objects.ts:7:1:7:16 | [DeclStmt] let enumObj = ... | type_definition_objects.ts:7:5:7:15 | [VariableDeclarator] enumObj = E | semmle.label | 1 | -| type_definition_objects.ts:7:1:7:16 | [DeclStmt] let enumObj = ... | type_definition_objects.ts:7:5:7:15 | [VariableDeclarator] enumObj = E | semmle.order | 1 | -| type_definition_objects.ts:7:5:7:15 | [VariableDeclarator] enumObj = E | type_definition_objects.ts:7:5:7:11 | [VarDecl] enumObj | semmle.label | 1 | -| type_definition_objects.ts:7:5:7:15 | [VariableDeclarator] enumObj = E | type_definition_objects.ts:7:5:7:11 | [VarDecl] enumObj | semmle.order | 1 | -| type_definition_objects.ts:7:5:7:15 | [VariableDeclarator] enumObj = E | type_definition_objects.ts:7:15:7:15 | [VarRef] E | semmle.label | 2 | -| type_definition_objects.ts:7:5:7:15 | [VariableDeclarator] enumObj = E | type_definition_objects.ts:7:15:7:15 | [VarRef] E | semmle.order | 2 | -| type_definition_objects.ts:9:1:9:22 | [ExportDeclaration] export ... e N {;} | type_definition_objects.ts:9:8:9:22 | [NamespaceDeclaration] namespace N {;} | semmle.label | 1 | -| type_definition_objects.ts:9:1:9:22 | [ExportDeclaration] export ... e N {;} | type_definition_objects.ts:9:8:9:22 | [NamespaceDeclaration] namespace N {;} | semmle.order | 1 | -| type_definition_objects.ts:9:8:9:22 | [NamespaceDeclaration] namespace N {;} | type_definition_objects.ts:9:18:9:18 | [VarDecl] N | semmle.label | 1 | -| type_definition_objects.ts:9:8:9:22 | [NamespaceDeclaration] namespace N {;} | type_definition_objects.ts:9:18:9:18 | [VarDecl] N | semmle.order | 1 | -| type_definition_objects.ts:9:8:9:22 | [NamespaceDeclaration] namespace N {;} | type_definition_objects.ts:9:21:9:21 | [EmptyStmt] ; | semmle.label | 2 | -| type_definition_objects.ts:9:8:9:22 | [NamespaceDeclaration] namespace N {;} | type_definition_objects.ts:9:21:9:21 | [EmptyStmt] ; | semmle.order | 2 | -| type_definition_objects.ts:10:1:10:21 | [DeclStmt] let namespaceObj = ... | type_definition_objects.ts:10:5:10:20 | [VariableDeclarator] namespaceObj = N | semmle.label | 1 | -| type_definition_objects.ts:10:1:10:21 | [DeclStmt] let namespaceObj = ... | type_definition_objects.ts:10:5:10:20 | [VariableDeclarator] namespaceObj = N | semmle.order | 1 | -| type_definition_objects.ts:10:5:10:20 | [VariableDeclarator] namespaceObj = N | type_definition_objects.ts:10:5:10:16 | [VarDecl] namespaceObj | semmle.label | 1 | -| type_definition_objects.ts:10:5:10:20 | [VariableDeclarator] namespaceObj = N | type_definition_objects.ts:10:5:10:16 | [VarDecl] namespaceObj | semmle.order | 1 | -| type_definition_objects.ts:10:5:10:20 | [VariableDeclarator] namespaceObj = N | type_definition_objects.ts:10:20:10:20 | [VarRef] N | semmle.label | 2 | -| type_definition_objects.ts:10:5:10:20 | [VariableDeclarator] namespaceObj = N | type_definition_objects.ts:10:20:10:20 | [VarRef] N | semmle.order | 2 | -| type_definitions.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | type_definitions.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.label | 1 | -| type_definitions.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | type_definitions.ts:1:8:1:17 | [ImportSpecifier] * as dummy | semmle.order | 1 | -| type_definitions.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | type_definitions.ts:1:24:1:32 | [Literal] "./dummy" | semmle.label | 2 | -| type_definitions.ts:1:1:1:33 | [ImportDeclaration] import ... dummy"; | type_definitions.ts:1:24:1:32 | [Literal] "./dummy" | semmle.order | 2 | -| type_definitions.ts:1:8:1:17 | [ImportSpecifier] * as dummy | type_definitions.ts:1:13:1:17 | [VarDecl] dummy | semmle.label | 1 | -| type_definitions.ts:1:8:1:17 | [ImportSpecifier] * as dummy | type_definitions.ts:1:13:1:17 | [VarDecl] dummy | semmle.order | 1 | -| type_definitions.ts:3:1:5:1 | [InterfaceDeclaration,TypeDefinition] interfa ... x: S; } | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| type_definitions.ts:3:1:5:1 | [InterfaceDeclaration,TypeDefinition] interfa ... x: S; } | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| type_definitions.ts:3:1:5:1 | [InterfaceDeclaration,TypeDefinition] interfa ... x: S; } | type_definitions.ts:3:11:3:11 | [Identifier] I | semmle.label | 1 | -| type_definitions.ts:3:1:5:1 | [InterfaceDeclaration,TypeDefinition] interfa ... x: S; } | type_definitions.ts:3:11:3:11 | [Identifier] I | semmle.order | 1 | -| type_definitions.ts:3:1:5:1 | [InterfaceDeclaration,TypeDefinition] interfa ... x: S; } | type_definitions.ts:4:3:4:7 | [FieldDeclaration] x: S; | semmle.label | 3 | -| type_definitions.ts:3:1:5:1 | [InterfaceDeclaration,TypeDefinition] interfa ... x: S; } | type_definitions.ts:4:3:4:7 | [FieldDeclaration] x: S; | semmle.order | 3 | -| type_definitions.ts:3:13:3:13 | [TypeParameter] S | type_definitions.ts:3:13:3:13 | [Identifier] S | semmle.label | 1 | -| type_definitions.ts:3:13:3:13 | [TypeParameter] S | type_definitions.ts:3:13:3:13 | [Identifier] S | semmle.order | 1 | -| type_definitions.ts:4:3:4:7 | [FieldDeclaration] x: S; | type_definitions.ts:4:3:4:3 | [Label] x | semmle.label | 1 | -| type_definitions.ts:4:3:4:7 | [FieldDeclaration] x: S; | type_definitions.ts:4:3:4:3 | [Label] x | semmle.order | 1 | -| type_definitions.ts:4:3:4:7 | [FieldDeclaration] x: S; | type_definitions.ts:4:6:4:6 | [LocalTypeAccess] S | semmle.label | 2 | -| type_definitions.ts:4:3:4:7 | [FieldDeclaration] x: S; | type_definitions.ts:4:6:4:6 | [LocalTypeAccess] S | semmle.order | 2 | -| type_definitions.ts:6:1:6:16 | [DeclStmt] let i = ... | type_definitions.ts:6:5:6:16 | [VariableDeclarator] i: I | semmle.label | 1 | -| type_definitions.ts:6:1:6:16 | [DeclStmt] let i = ... | type_definitions.ts:6:5:6:16 | [VariableDeclarator] i: I | semmle.order | 1 | -| type_definitions.ts:6:5:6:16 | [VariableDeclarator] i: I | type_definitions.ts:6:5:6:5 | [VarDecl] i | semmle.label | 1 | -| type_definitions.ts:6:5:6:16 | [VariableDeclarator] i: I | type_definitions.ts:6:5:6:5 | [VarDecl] i | semmle.order | 1 | -| type_definitions.ts:6:5:6:16 | [VariableDeclarator] i: I | type_definitions.ts:6:8:6:16 | [GenericTypeExpr] I | semmle.label | 2 | -| type_definitions.ts:6:5:6:16 | [VariableDeclarator] i: I | type_definitions.ts:6:8:6:16 | [GenericTypeExpr] I | semmle.order | 2 | -| type_definitions.ts:6:8:6:16 | [GenericTypeExpr] I | type_definitions.ts:6:8:6:8 | [LocalTypeAccess] I | semmle.label | 1 | -| type_definitions.ts:6:8:6:16 | [GenericTypeExpr] I | type_definitions.ts:6:8:6:8 | [LocalTypeAccess] I | semmle.order | 1 | -| type_definitions.ts:6:8:6:16 | [GenericTypeExpr] I | type_definitions.ts:6:10:6:15 | [KeywordTypeExpr] number | semmle.label | 2 | -| type_definitions.ts:6:8:6:16 | [GenericTypeExpr] I | type_definitions.ts:6:10:6:15 | [KeywordTypeExpr] number | semmle.order | 2 | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | type_definitions.ts:8:7:8:7 | [VarDecl] C | semmle.label | 1 | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | type_definitions.ts:8:7:8:7 | [VarDecl] C | semmle.order | 1 | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | type_definitions.ts:8:8:8:7 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.label | 2 | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | type_definitions.ts:8:8:8:7 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | semmle.order | 2 | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | type_definitions.ts:9:3:9:6 | [FieldDeclaration] x: T | semmle.label | 4 | -| type_definitions.ts:8:1:10:1 | [ClassDefinition,TypeDefinition] class C ... x: T } | type_definitions.ts:9:3:9:6 | [FieldDeclaration] x: T | semmle.order | 4 | -| type_definitions.ts:8:8:8:7 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | type_definitions.ts:8:8:8:7 | [FunctionExpr] () {} | semmle.label | 2 | -| type_definitions.ts:8:8:8:7 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | type_definitions.ts:8:8:8:7 | [FunctionExpr] () {} | semmle.order | 2 | -| type_definitions.ts:8:8:8:7 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | type_definitions.ts:8:8:8:7 | [Label] constructor | semmle.label | 1 | -| type_definitions.ts:8:8:8:7 | [ClassInitializedMember,ConstructorDefinition] constructor() {} | type_definitions.ts:8:8:8:7 | [Label] constructor | semmle.order | 1 | -| type_definitions.ts:8:8:8:7 | [FunctionExpr] () {} | type_definitions.ts:8:8:8:7 | [BlockStmt] {} | semmle.label | 5 | -| type_definitions.ts:8:8:8:7 | [FunctionExpr] () {} | type_definitions.ts:8:8:8:7 | [BlockStmt] {} | semmle.order | 5 | -| type_definitions.ts:8:9:8:9 | [TypeParameter] T | type_definitions.ts:8:9:8:9 | [Identifier] T | semmle.label | 1 | -| type_definitions.ts:8:9:8:9 | [TypeParameter] T | type_definitions.ts:8:9:8:9 | [Identifier] T | semmle.order | 1 | -| type_definitions.ts:9:3:9:6 | [FieldDeclaration] x: T | type_definitions.ts:9:3:9:3 | [Label] x | semmle.label | 1 | -| type_definitions.ts:9:3:9:6 | [FieldDeclaration] x: T | type_definitions.ts:9:3:9:3 | [Label] x | semmle.order | 1 | -| type_definitions.ts:9:3:9:6 | [FieldDeclaration] x: T | type_definitions.ts:9:6:9:6 | [LocalTypeAccess] T | semmle.label | 2 | -| type_definitions.ts:9:3:9:6 | [FieldDeclaration] x: T | type_definitions.ts:9:6:9:6 | [LocalTypeAccess] T | semmle.order | 2 | -| type_definitions.ts:11:1:11:17 | [DeclStmt] let c = ... | type_definitions.ts:11:5:11:16 | [VariableDeclarator] c: C | semmle.label | 1 | -| type_definitions.ts:11:1:11:17 | [DeclStmt] let c = ... | type_definitions.ts:11:5:11:16 | [VariableDeclarator] c: C | semmle.order | 1 | -| type_definitions.ts:11:5:11:16 | [VariableDeclarator] c: C | type_definitions.ts:11:5:11:5 | [VarDecl] c | semmle.label | 1 | -| type_definitions.ts:11:5:11:16 | [VariableDeclarator] c: C | type_definitions.ts:11:5:11:5 | [VarDecl] c | semmle.order | 1 | -| type_definitions.ts:11:5:11:16 | [VariableDeclarator] c: C | type_definitions.ts:11:8:11:16 | [GenericTypeExpr] C | semmle.label | 2 | -| type_definitions.ts:11:5:11:16 | [VariableDeclarator] c: C | type_definitions.ts:11:8:11:16 | [GenericTypeExpr] C | semmle.order | 2 | -| type_definitions.ts:11:8:11:16 | [GenericTypeExpr] C | type_definitions.ts:11:8:11:8 | [LocalTypeAccess] C | semmle.label | 1 | -| type_definitions.ts:11:8:11:16 | [GenericTypeExpr] C | type_definitions.ts:11:8:11:8 | [LocalTypeAccess] C | semmle.order | 1 | -| type_definitions.ts:11:8:11:16 | [GenericTypeExpr] C | type_definitions.ts:11:10:11:15 | [KeywordTypeExpr] number | semmle.label | 2 | -| type_definitions.ts:11:8:11:16 | [GenericTypeExpr] C | type_definitions.ts:11:10:11:15 | [KeywordTypeExpr] number | semmle.order | 2 | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | type_definitions.ts:13:6:13:10 | [VarDecl] Color | semmle.label | 1 | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | type_definitions.ts:13:6:13:10 | [VarDecl] Color | semmle.order | 1 | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | type_definitions.ts:14:3:14:5 | [EnumMember,TypeDefinition] red | semmle.label | 2 | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | type_definitions.ts:14:3:14:5 | [EnumMember,TypeDefinition] red | semmle.order | 2 | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | type_definitions.ts:14:8:14:12 | [EnumMember,TypeDefinition] green | semmle.label | 3 | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | type_definitions.ts:14:8:14:12 | [EnumMember,TypeDefinition] green | semmle.order | 3 | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | type_definitions.ts:14:15:14:18 | [EnumMember,TypeDefinition] blue | semmle.label | 4 | -| type_definitions.ts:13:1:15:1 | [EnumDeclaration,TypeDefinition] enum Co ... blue } | type_definitions.ts:14:15:14:18 | [EnumMember,TypeDefinition] blue | semmle.order | 4 | -| type_definitions.ts:14:3:14:5 | [EnumMember,TypeDefinition] red | type_definitions.ts:14:3:14:5 | [VarDecl] red | semmle.label | 1 | -| type_definitions.ts:14:3:14:5 | [EnumMember,TypeDefinition] red | type_definitions.ts:14:3:14:5 | [VarDecl] red | semmle.order | 1 | -| type_definitions.ts:14:8:14:12 | [EnumMember,TypeDefinition] green | type_definitions.ts:14:8:14:12 | [VarDecl] green | semmle.label | 1 | -| type_definitions.ts:14:8:14:12 | [EnumMember,TypeDefinition] green | type_definitions.ts:14:8:14:12 | [VarDecl] green | semmle.order | 1 | -| type_definitions.ts:14:15:14:18 | [EnumMember,TypeDefinition] blue | type_definitions.ts:14:15:14:18 | [VarDecl] blue | semmle.label | 1 | -| type_definitions.ts:14:15:14:18 | [EnumMember,TypeDefinition] blue | type_definitions.ts:14:15:14:18 | [VarDecl] blue | semmle.order | 1 | -| type_definitions.ts:16:1:16:17 | [DeclStmt] let color = ... | type_definitions.ts:16:5:16:16 | [VariableDeclarator] color: Color | semmle.label | 1 | -| type_definitions.ts:16:1:16:17 | [DeclStmt] let color = ... | type_definitions.ts:16:5:16:16 | [VariableDeclarator] color: Color | semmle.order | 1 | -| type_definitions.ts:16:5:16:16 | [VariableDeclarator] color: Color | type_definitions.ts:16:5:16:9 | [VarDecl] color | semmle.label | 1 | -| type_definitions.ts:16:5:16:16 | [VariableDeclarator] color: Color | type_definitions.ts:16:5:16:9 | [VarDecl] color | semmle.order | 1 | -| type_definitions.ts:16:5:16:16 | [VariableDeclarator] color: Color | type_definitions.ts:16:12:16:16 | [LocalTypeAccess] Color | semmle.label | 2 | -| type_definitions.ts:16:5:16:16 | [VariableDeclarator] color: Color | type_definitions.ts:16:12:16:16 | [LocalTypeAccess] Color | semmle.order | 2 | -| type_definitions.ts:18:1:18:33 | [EnumDeclaration,TypeDefinition] enum En ... ember } | type_definitions.ts:18:6:18:22 | [VarDecl] EnumWithOneMember | semmle.label | 1 | -| type_definitions.ts:18:1:18:33 | [EnumDeclaration,TypeDefinition] enum En ... ember } | type_definitions.ts:18:6:18:22 | [VarDecl] EnumWithOneMember | semmle.order | 1 | -| type_definitions.ts:18:1:18:33 | [EnumDeclaration,TypeDefinition] enum En ... ember } | type_definitions.ts:18:26:18:31 | [EnumMember,TypeDefinition] member | semmle.label | 2 | -| type_definitions.ts:18:1:18:33 | [EnumDeclaration,TypeDefinition] enum En ... ember } | type_definitions.ts:18:26:18:31 | [EnumMember,TypeDefinition] member | semmle.order | 2 | -| type_definitions.ts:18:26:18:31 | [EnumMember,TypeDefinition] member | type_definitions.ts:18:26:18:31 | [VarDecl] member | semmle.label | 1 | -| type_definitions.ts:18:26:18:31 | [EnumMember,TypeDefinition] member | type_definitions.ts:18:26:18:31 | [VarDecl] member | semmle.order | 1 | -| type_definitions.ts:19:1:19:25 | [DeclStmt] let e = ... | type_definitions.ts:19:5:19:24 | [VariableDeclarator] e: EnumWithOneMember | semmle.label | 1 | -| type_definitions.ts:19:1:19:25 | [DeclStmt] let e = ... | type_definitions.ts:19:5:19:24 | [VariableDeclarator] e: EnumWithOneMember | semmle.order | 1 | -| type_definitions.ts:19:5:19:24 | [VariableDeclarator] e: EnumWithOneMember | type_definitions.ts:19:5:19:5 | [VarDecl] e | semmle.label | 1 | -| type_definitions.ts:19:5:19:24 | [VariableDeclarator] e: EnumWithOneMember | type_definitions.ts:19:5:19:5 | [VarDecl] e | semmle.order | 1 | -| type_definitions.ts:19:5:19:24 | [VariableDeclarator] e: EnumWithOneMember | type_definitions.ts:19:8:19:24 | [LocalTypeAccess] EnumWithOneMember | semmle.label | 2 | -| type_definitions.ts:19:5:19:24 | [VariableDeclarator] e: EnumWithOneMember | type_definitions.ts:19:8:19:24 | [LocalTypeAccess] EnumWithOneMember | semmle.order | 2 | -| type_definitions.ts:21:1:21:20 | [TypeAliasDeclaration,TypeDefinition] type Alias = T[]; | file://:0:0:0:0 | (TypeParameters) | semmle.label | -100 | -| type_definitions.ts:21:1:21:20 | [TypeAliasDeclaration,TypeDefinition] type Alias = T[]; | file://:0:0:0:0 | (TypeParameters) | semmle.order | -100 | -| type_definitions.ts:21:1:21:20 | [TypeAliasDeclaration,TypeDefinition] type Alias = T[]; | type_definitions.ts:21:6:21:10 | [Identifier] Alias | semmle.label | 1 | -| type_definitions.ts:21:1:21:20 | [TypeAliasDeclaration,TypeDefinition] type Alias = T[]; | type_definitions.ts:21:6:21:10 | [Identifier] Alias | semmle.order | 1 | -| type_definitions.ts:21:1:21:20 | [TypeAliasDeclaration,TypeDefinition] type Alias = T[]; | type_definitions.ts:21:17:21:19 | [ArrayTypeExpr] T[] | semmle.label | 3 | -| type_definitions.ts:21:1:21:20 | [TypeAliasDeclaration,TypeDefinition] type Alias = T[]; | type_definitions.ts:21:17:21:19 | [ArrayTypeExpr] T[] | semmle.order | 3 | -| type_definitions.ts:21:12:21:12 | [TypeParameter] T | type_definitions.ts:21:12:21:12 | [Identifier] T | semmle.label | 1 | -| type_definitions.ts:21:12:21:12 | [TypeParameter] T | type_definitions.ts:21:12:21:12 | [Identifier] T | semmle.order | 1 | -| type_definitions.ts:21:17:21:19 | [ArrayTypeExpr] T[] | type_definitions.ts:21:17:21:17 | [LocalTypeAccess] T | semmle.label | 1 | -| type_definitions.ts:21:17:21:19 | [ArrayTypeExpr] T[] | type_definitions.ts:21:17:21:17 | [LocalTypeAccess] T | semmle.order | 1 | -| type_definitions.ts:22:1:22:39 | [DeclStmt] let aliasForNumberArray = ... | type_definitions.ts:22:5:22:38 | [VariableDeclarator] aliasFo ... number> | semmle.label | 1 | -| type_definitions.ts:22:1:22:39 | [DeclStmt] let aliasForNumberArray = ... | type_definitions.ts:22:5:22:38 | [VariableDeclarator] aliasFo ... number> | semmle.order | 1 | -| type_definitions.ts:22:5:22:38 | [VariableDeclarator] aliasFo ... number> | type_definitions.ts:22:5:22:23 | [VarDecl] aliasForNumberArray | semmle.label | 1 | -| type_definitions.ts:22:5:22:38 | [VariableDeclarator] aliasFo ... number> | type_definitions.ts:22:5:22:23 | [VarDecl] aliasForNumberArray | semmle.order | 1 | -| type_definitions.ts:22:5:22:38 | [VariableDeclarator] aliasFo ... number> | type_definitions.ts:22:26:22:38 | [GenericTypeExpr] Alias | semmle.label | 2 | -| type_definitions.ts:22:5:22:38 | [VariableDeclarator] aliasFo ... number> | type_definitions.ts:22:26:22:38 | [GenericTypeExpr] Alias | semmle.order | 2 | -| type_definitions.ts:22:26:22:38 | [GenericTypeExpr] Alias | type_definitions.ts:22:26:22:30 | [LocalTypeAccess] Alias | semmle.label | 1 | -| type_definitions.ts:22:26:22:38 | [GenericTypeExpr] Alias | type_definitions.ts:22:26:22:30 | [LocalTypeAccess] Alias | semmle.order | 1 | -| type_definitions.ts:22:26:22:38 | [GenericTypeExpr] Alias | type_definitions.ts:22:32:22:37 | [KeywordTypeExpr] number | semmle.label | 2 | -| type_definitions.ts:22:26:22:38 | [GenericTypeExpr] Alias | type_definitions.ts:22:32:22:37 | [KeywordTypeExpr] number | semmle.order | 2 | -graphProperties -| semmle.graphKind | tree | diff --git a/javascript/ql/test/library-tests/TypeScript/Types/printAst.ql b/javascript/ql/test/library-tests/TypeScript/Types/printAst.ql deleted file mode 100644 index 248ea7ad396b..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/printAst.ql +++ /dev/null @@ -1,2 +0,0 @@ -import javascript -import semmle.javascript.PrintAst diff --git a/javascript/ql/test/library-tests/TypeScript/Types/something.json b/javascript/ql/test/library-tests/TypeScript/Types/something.json deleted file mode 100644 index 8a79687628fe..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/something.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "foo": "bar" -} \ No newline at end of file diff --git a/javascript/ql/test/library-tests/TypeScript/Types/tests.expected b/javascript/ql/test/library-tests/TypeScript/Types/tests.expected deleted file mode 100644 index b9e11cfa92f3..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/tests.expected +++ /dev/null @@ -1,1545 +0,0 @@ -booleans -| boolean | -getExprType -| boolean-type.ts:1:13:1:17 | dummy | typeof dummy.ts | -| boolean-type.ts:1:24:1:32 | "./dummy" | any | -| boolean-type.ts:3:5:3:9 | true1 | true | -| boolean-type.ts:4:5:4:9 | true2 | true | -| boolean-type.ts:6:5:6:10 | false1 | false | -| boolean-type.ts:7:5:7:10 | false2 | false | -| boolean-type.ts:9:5:9:12 | boolean1 | boolean | -| boolean-type.ts:10:5:10:12 | boolean2 | boolean | -| boolean-type.ts:11:5:11:12 | boolean3 | boolean | -| boolean-type.ts:13:5:13:12 | boolean4 | boolean | -| boolean-type.ts:14:5:14:12 | boolean5 | boolean | -| boolean-type.ts:15:5:15:12 | boolean6 | boolean | -| dummy.ts:2:12:2:12 | x | number | -| dummy.ts:2:16:2:16 | 5 | 5 | -| dummy.ts:4:12:4:14 | reg | RegExp | -| dummy.ts:4:18:4:23 | /ab+c/ | RegExp | -| middle-rest.ts:1:5:1:7 | foo | [boolean, ...string[], number] | -| middle-rest.ts:3:1:3:3 | foo | [boolean, ...string[], number] | -| middle-rest.ts:3:1:3:26 | foo = [ ... ", 123] | [true, string, number] | -| middle-rest.ts:3:7:3:26 | [true, "hello", 123] | [boolean, ...string[], number] | -| middle-rest.ts:3:8:3:11 | true | true | -| middle-rest.ts:3:14:3:20 | "hello" | "hello" | -| middle-rest.ts:3:23:3:25 | 123 | 123 | -| tst.ts:1:13:1:17 | dummy | typeof dummy.ts | -| tst.ts:1:24:1:32 | "./dummy" | any | -| tst.ts:3:5:3:10 | numVar | number | -| tst.ts:5:5:5:8 | num1 | number | -| tst.ts:5:12:5:17 | numVar | number | -| tst.ts:6:5:6:8 | num2 | number | -| tst.ts:6:12:6:12 | 5 | 5 | -| tst.ts:7:5:7:8 | num3 | number | -| tst.ts:7:12:7:15 | num1 | number | -| tst.ts:7:12:7:22 | num1 + num2 | number | -| tst.ts:7:19:7:22 | num2 | number | -| tst.ts:9:5:9:10 | strVar | string | -| tst.ts:10:5:10:9 | hello | string | -| tst.ts:10:13:10:19 | "hello" | "hello" | -| tst.ts:11:5:11:9 | world | string | -| tst.ts:11:13:11:19 | "world" | "world" | -| tst.ts:12:5:12:7 | msg | string | -| tst.ts:12:11:12:15 | hello | string | -| tst.ts:12:11:12:21 | hello + " " | string | -| tst.ts:12:11:12:29 | hello + " " + world | string | -| tst.ts:12:19:12:21 | " " | " " | -| tst.ts:12:25:12:29 | world | string | -| tst.ts:14:10:14:15 | concat | (x: string, y: string) => string | -| tst.ts:14:17:14:17 | x | string | -| tst.ts:14:28:14:28 | y | string | -| tst.ts:14:56:14:56 | x | string | -| tst.ts:14:56:14:60 | x + y | string | -| tst.ts:14:60:14:60 | y | string | -| tst.ts:16:10:16:12 | add | (x: number, y: number) => number | -| tst.ts:16:14:16:14 | x | number | -| tst.ts:16:25:16:25 | y | number | -| tst.ts:16:53:16:53 | x | number | -| tst.ts:16:53:16:57 | x + y | number | -| tst.ts:16:57:16:57 | y | number | -| tst.ts:18:10:18:16 | untyped | (x: any, y: any) => any | -| tst.ts:18:18:18:18 | x | any | -| tst.ts:18:21:18:21 | y | any | -| tst.ts:18:33:18:33 | x | any | -| tst.ts:18:33:18:37 | x + y | any | -| tst.ts:18:37:18:37 | y | any | -| tst.ts:20:10:20:21 | partialTyped | (x: any, y: string) => string | -| tst.ts:20:23:20:23 | x | any | -| tst.ts:20:26:20:26 | y | string | -| tst.ts:20:46:20:46 | x | any | -| tst.ts:20:46:20:50 | x + y | string | -| tst.ts:20:50:20:50 | y | string | -| tst.ts:22:10:22:20 | numFromLoop | number | -| tst.ts:22:25:22:30 | [1, 2] | number[] | -| tst.ts:22:26:22:26 | 1 | 1 | -| tst.ts:22:29:22:29 | 2 | 2 | -| tst.ts:24:5:24:9 | array | number[] | -| tst.ts:26:5:26:12 | voidType | () => void | -| tst.ts:26:15:26:24 | () => void | () => void | -| tst.ts:27:5:27:17 | undefinedType | undefined | -| tst.ts:28:5:28:12 | nullType | null | -| tst.ts:29:5:29:13 | neverType | () => never | -| tst.ts:29:16:29:26 | () => never | () => never | -| tst.ts:30:5:30:14 | symbolType | symbol | -| tst.ts:31:7:31:22 | uniqueSymbolType | typeof uniqueSymbolType | -| tst.ts:32:5:32:14 | objectType | object | -| tst.ts:33:5:33:16 | intersection | string & { x: string; } | -| tst.ts:33:29:33:29 | x | string | -| tst.ts:34:5:34:9 | tuple | [number, string] | -| tst.ts:36:5:36:28 | tupleWi ... Element | [number, string, number?] | -| tst.ts:37:5:37:14 | emptyTuple | [] | -| tst.ts:38:5:38:24 | tupleWithRestElement | [number, ...string[]] | -| tst.ts:39:5:39:36 | tupleWi ... lements | [number, string?, ...number[]] | -| tst.ts:40:5:40:15 | unknownType | unknown | -| tst.ts:42:5:42:21 | constArrayLiteral | readonly [1, 2] | -| tst.ts:42:25:42:30 | [1, 2] | readonly [1, 2] | -| tst.ts:42:25:42:39 | [1, 2] as const | readonly [1, 2] | -| tst.ts:42:26:42:26 | 1 | 1 | -| tst.ts:42:29:42:29 | 2 | 2 | -| tst.ts:43:5:43:22 | constObjectLiteral | { readonly foo: "foo"; } | -| tst.ts:43:26:43:39 | { foo: "foo" } | { readonly foo: "foo"; } | -| tst.ts:43:26:43:48 | { foo: ... s const | { readonly foo: "foo"; } | -| tst.ts:43:28:43:30 | foo | "foo" | -| tst.ts:43:33:43:37 | "foo" | "foo" | -| tst.ts:47:8:47:8 | e | unknown | -| tst.ts:48:7:48:14 | typeof e | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| tst.ts:48:7:48:27 | typeof ... string" | boolean | -| tst.ts:48:14:48:14 | e | unknown | -| tst.ts:48:20:48:27 | "string" | "string" | -| tst.ts:49:11:49:11 | b | string | -| tst.ts:49:24:49:24 | e | string | -| tst.ts:55:3:55:9 | getArea | () => number | -| tst.ts:55:3:55:20 | getArea(): number; | () => number | -| tst.ts:59:3:59:9 | getArea | () => number | -| tst.ts:59:3:59:20 | getArea(): number; | () => number | -| tst.ts:63:5:63:8 | Ctor | abstract new () => HasArea | -| tst.ts:63:11:63:36 | abstrac ... HasArea | abstract new () => HasArea | -| tst.ts:63:40:63:44 | Shape | any | -| tst.ts:65:17:65:23 | myUnion | true | -| tst.ts:65:35:65:46 | stillMyUnion | true | -| tst.ts:66:5:66:10 | union1 | MyUnion | -| tst.ts:66:23:66:37 | {myUnion: true} | MyUnion | -| tst.ts:66:24:66:30 | myUnion | true | -| tst.ts:66:33:66:36 | true | true | -| tst.ts:68:28:68:41 | yetAnotherType | true | -| tst.ts:69:5:69:10 | union2 | MyUnion2 | -| tst.ts:69:24:69:45 | {yetAno ... : true} | MyUnion2 | -| tst.ts:69:25:69:38 | yetAnotherType | true | -| tst.ts:69:41:69:44 | true | true | -| tst.ts:71:8:71:11 | TS43 | typeof TS43 in tst.ts | -| tst.ts:74:5:74:22 | get size(): number | number | -| tst.ts:74:9:74:12 | size | number | -| tst.ts:75:5:75:47 | set siz ... olean); | number | -| tst.ts:75:9:75:12 | size | number | -| tst.ts:75:14:75:18 | value | string \| number \| boolean | -| tst.ts:78:16:78:20 | Thing | Thing | -| tst.ts:79:13:79:13 | 0 | 0 | -| tst.ts:81:5:83:5 | get siz ... ;\\n } | number | -| tst.ts:81:9:81:12 | size | number | -| tst.ts:82:14:82:23 | this.#size | number | -| tst.ts:85:5:87:5 | set siz ... ;\\n } | number | -| tst.ts:85:9:85:12 | size | number | -| tst.ts:85:14:85:18 | value | string \| number \| boolean | -| tst.ts:86:7:86:16 | this.#size | number | -| tst.ts:86:7:86:32 | this.#s ... (value) | number | -| tst.ts:86:20:86:25 | Number | NumberConstructor | -| tst.ts:86:20:86:32 | Number(value) | number | -| tst.ts:86:27:86:31 | value | string \| number \| boolean | -| tst.ts:91:9:91:13 | Super | Super | -| tst.ts:92:5:92:10 | random | () => number | -| tst.ts:92:5:94:5 | random( ... ;\\n } | () => number | -| tst.ts:93:14:93:14 | 4 | 4 | -| tst.ts:97:9:97:11 | Sub | Sub | -| tst.ts:97:21:97:25 | Super | Super | -| tst.ts:98:5:100:5 | overrid ... ;\\n } | () => number | -| tst.ts:98:14:98:19 | random | () => number | -| tst.ts:99:14:99:25 | super.random | () => number | -| tst.ts:99:14:99:27 | super.random() | number | -| tst.ts:99:14:99:32 | super.random() * 10 | number | -| tst.ts:99:20:99:25 | random | () => number | -| tst.ts:99:31:99:32 | 10 | 10 | -| tst.ts:104:16:104:16 | s | string | -| tst.ts:106:13:106:18 | hello | any | -| tst.ts:106:21:106:21 | s | string | -| tst.ts:110:15:110:16 | s2 | "1-2-3" | -| tst.ts:112:3:112:9 | s1 = s2 | "1-2-3" | -| tst.ts:112:8:112:9 | s2 | "1-2-3" | -| tst.ts:116:9:116:11 | Foo | Foo | -| tst.ts:117:5:119:5 | #someMe ... ;\\n } | () => number | -| tst.ts:118:14:118:15 | 42 | 42 | -| tst.ts:121:5:123:5 | get #so ... ;\\n } | number | -| tst.ts:122:14:122:16 | 100 | 100 | -| tst.ts:125:5:125:16 | publicMethod | () => number | -| tst.ts:125:5:128:5 | publicM ... ;\\n } | () => number | -| tst.ts:126:7:126:22 | this.#someMethod | () => number | -| tst.ts:126:7:126:24 | this.#someMethod() | number | -| tst.ts:127:14:127:28 | this.#someValue | number | -| tst.ts:132:8:132:11 | TS44 | typeof TS44 in tst.ts | -| tst.ts:133:12:133:14 | foo | (arg: unknown) => void | -| tst.ts:133:16:133:18 | arg | unknown | -| tst.ts:134:11:134:21 | argIsString | boolean | -| tst.ts:134:25:134:34 | typeof arg | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| tst.ts:134:25:134:47 | typeof ... string" | boolean | -| tst.ts:134:32:134:34 | arg | unknown | -| tst.ts:134:40:134:47 | "string" | "string" | -| tst.ts:135:9:135:19 | argIsString | boolean | -| tst.ts:136:15:136:19 | upper | string | -| tst.ts:136:23:136:25 | arg | string | -| tst.ts:136:23:136:37 | arg.toUpperCase | () => string | -| tst.ts:136:23:136:39 | arg.toUpperCase() | string | -| tst.ts:136:27:136:37 | toUpperCase | () => string | -| tst.ts:141:11:141:14 | kind | "circle" | -| tst.ts:141:27:141:32 | radius | number | -| tst.ts:142:11:142:14 | kind | "square" | -| tst.ts:142:27:142:36 | sideLength | number | -| tst.ts:144:12:144:15 | side | (shape: Shape) => number | -| tst.ts:144:17:144:21 | shape | Shape | -| tst.ts:145:15:145:18 | kind | "circle" \| "square" | -| tst.ts:145:15:145:18 | kind | "circle" \| "square" | -| tst.ts:145:24:145:28 | shape | Shape | -| tst.ts:147:11:147:14 | kind | "circle" \| "square" | -| tst.ts:147:11:147:27 | kind === "circle" | boolean | -| tst.ts:147:20:147:27 | "circle" | "circle" | -| tst.ts:147:39:147:43 | shape | { kind: "circle"; radius: number; } | -| tst.ts:147:39:147:50 | shape.radius | number | -| tst.ts:147:45:147:50 | radius | number | -| tst.ts:148:21:148:25 | shape | { kind: "square"; sideLength: number; } | -| tst.ts:148:21:148:36 | shape.sideLength | number | -| tst.ts:148:27:148:36 | sideLength | number | -| tst.ts:151:12:151:22 | symbolIndex | () => void | -| tst.ts:153:7:153:28 | [sym: s ... number; | any | -| tst.ts:153:8:153:10 | sym | symbol | -| tst.ts:154:7:154:28 | [key: s ... string; | any | -| tst.ts:154:8:154:10 | key | string | -| tst.ts:155:7:155:29 | [num: n ... oolean; | any | -| tst.ts:155:8:155:10 | num | number | -| tst.ts:158:9:158:14 | colors | Colors | -| tst.ts:158:26:158:27 | {} | Colors | -| tst.ts:159:11:159:13 | red | number | -| tst.ts:159:17:159:22 | colors | Colors | -| tst.ts:159:17:159:37 | colors[ ... "red")] | number | -| tst.ts:159:24:159:29 | Symbol | SymbolConstructor | -| tst.ts:159:24:159:36 | Symbol("red") | symbol | -| tst.ts:159:31:159:35 | "red" | "red" | -| tst.ts:160:11:160:15 | green | string | -| tst.ts:160:19:160:24 | colors | Colors | -| tst.ts:160:19:160:33 | colors["green"] | string | -| tst.ts:160:26:160:32 | "green" | "green" | -| tst.ts:161:11:161:14 | blue | boolean | -| tst.ts:161:18:161:23 | colors | Colors | -| tst.ts:161:18:161:26 | colors[2] | boolean | -| tst.ts:161:25:161:25 | 2 | 2 | -| tst.ts:164:12:164:29 | stringPatternIndex | () => void | -| tst.ts:166:7:166:37 | [key: ` ... number; | any | -| tst.ts:168:9:168:11 | bla | Foo | -| tst.ts:168:21:168:22 | {} | Foo | -| tst.ts:169:11:169:13 | bar | number | -| tst.ts:169:17:169:19 | bla | Foo | -| tst.ts:169:17:169:28 | bla[`foo-1`] | number | -| tst.ts:169:21:169:27 | `foo-1` | "foo-1" | -| tst.ts:169:21:169:27 | `foo-1` | "foo-1" | -| tst.ts:172:7:172:42 | [optNam ... oolean; | any | -| tst.ts:172:8:172:14 | optName | string \| symbol | -| tst.ts:175:11:175:14 | data | Data | -| tst.ts:175:24:175:25 | {} | Data | -| tst.ts:176:11:176:13 | baz | boolean | -| tst.ts:176:17:176:20 | data | Data | -| tst.ts:176:17:176:27 | data["foo"] | boolean | -| tst.ts:176:22:176:26 | "foo" | "foo" | -| tst.ts:179:9:179:11 | Foo | Foo | -| tst.ts:180:21:180:21 | 0 | 0 | -| tst.ts:182:5:184:5 | get cou ... ;\\n } | number | -| tst.ts:182:9:182:13 | count | number | -| tst.ts:183:16:183:18 | Foo | typeof Foo in tst.ts:132 | -| tst.ts:183:16:183:25 | Foo.#count | number | -| tst.ts:186:7:186:9 | Foo | typeof Foo in tst.ts:132 | -| tst.ts:186:7:186:16 | Foo.#count | number | -| tst.ts:186:7:186:21 | Foo.#count += 3 | number | -| tst.ts:186:21:186:21 | 3 | 3 | -| tst.ts:189:11:189:15 | count | number | -| tst.ts:189:19:189:21 | Foo | typeof Foo in tst.ts:132 | -| tst.ts:189:19:189:28 | Foo.#count | number | -| tst.ts:195:8:195:11 | TS45 | typeof TS45 in tst.ts | -| tst.ts:207:5:207:8 | body | string | -| tst.ts:212:7:212:13 | message | string | -| tst.ts:215:19:215:25 | handler | (r: Success \| Error) => void | -| tst.ts:215:27:215:27 | r | Success \| Error | -| tst.ts:216:11:216:11 | r | Success \| Error | -| tst.ts:216:11:216:34 | r.type ... uccess" | boolean | -| tst.ts:216:22:216:34 | "HttpSuccess" | "HttpSuccess" | -| tst.ts:218:15:218:19 | token | string | -| tst.ts:218:23:218:23 | r | Success | -| tst.ts:218:23:218:28 | r.body | string | -| tst.ts:218:25:218:28 | body | string | -| tst.ts:222:9:222:14 | Person | Person | -| tst.ts:224:5:226:5 | constru ... ;\\n } | any | -| tst.ts:224:17:224:20 | name | string | -| tst.ts:225:9:225:18 | this.#name | string | -| tst.ts:225:9:225:25 | this.#name = name | string | -| tst.ts:225:22:225:25 | name | string | -| tst.ts:228:5:228:10 | equals | (other: unknown) => boolean | -| tst.ts:228:5:233:5 | equals( ... .\\n } | (other: unknown) => boolean | -| tst.ts:228:12:228:16 | other | unknown | -| tst.ts:229:16:229:20 | other | unknown | -| tst.ts:229:16:230:37 | other & ... object" | boolean | -| tst.ts:229:16:231:26 | other & ... n other | boolean | -| tst.ts:229:16:232:38 | other & ... r.#name | boolean | -| tst.ts:230:13:230:24 | typeof other | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| tst.ts:230:13:230:37 | typeof ... object" | boolean | -| tst.ts:230:20:230:24 | other | unknown | -| tst.ts:230:30:230:37 | "object" | "object" | -| tst.ts:231:13:231:26 | #name in other | boolean | -| tst.ts:231:22:231:26 | other | object | -| tst.ts:232:13:232:22 | this.#name | string | -| tst.ts:232:13:232:38 | this.#n ... r.#name | boolean | -| tst.ts:232:28:232:32 | other | Person | -| tst.ts:232:28:232:38 | other.#name | string | -| tst.ts:237:13:237:16 | Foo3 | { foo: string; } | -| tst.ts:237:23:237:40 | "./something.json" | any | -| tst.ts:238:5:238:7 | foo | string | -| tst.ts:238:11:238:14 | Foo3 | { foo: string; } | -| tst.ts:238:11:238:18 | Foo3.foo | string | -| tst.ts:238:16:238:18 | foo | string | -| tst.ts:240:8:240:11 | TS46 | typeof TS46 in tst.ts | -| tst.ts:241:9:241:12 | Base | Base | -| tst.ts:243:9:243:15 | Derived | Derived | -| tst.ts:243:25:243:28 | Base | Base | -| tst.ts:244:5:244:10 | myProp | boolean | -| tst.ts:244:14:244:17 | true | true | -| tst.ts:246:5:249:5 | constru ... ;\\n } | any | -| tst.ts:247:7:247:13 | console | Console | -| tst.ts:247:7:247:17 | console.log | (...data: any[]) => void | -| tst.ts:247:7:247:51 | console ... per()") | void | -| tst.ts:247:15:247:17 | log | (...data: any[]) => void | -| tst.ts:247:19:247:50 | "Doing ... uper()" | "Doing something before super()" | -| tst.ts:248:7:248:13 | super() | void | -| tst.ts:253:9:253:12 | kind | "NumberContents" | -| tst.ts:253:33:253:39 | payload | number | -| tst.ts:254:9:254:12 | kind | "StringContents" | -| tst.ts:254:33:254:39 | payload | string | -| tst.ts:256:12:256:24 | processAction | (action: Action) => void | -| tst.ts:256:26:256:31 | action | Action | -| tst.ts:257:13:257:16 | kind | "NumberContents" \| "StringContents" | -| tst.ts:257:13:257:16 | kind | "NumberContents" \| "StringContents" | -| tst.ts:257:19:257:25 | payload | string \| number | -| tst.ts:257:19:257:25 | payload | string \| number | -| tst.ts:257:31:257:36 | action | Action | -| tst.ts:258:9:258:12 | kind | "NumberContents" \| "StringContents" | -| tst.ts:258:9:258:33 | kind == ... ntents" | boolean | -| tst.ts:258:18:258:33 | "NumberContents" | "NumberContents" | -| tst.ts:259:7:259:13 | console | Console | -| tst.ts:259:7:259:17 | console.log | (...data: any[]) => void | -| tst.ts:259:7:259:36 | console ... ixed()) | void | -| tst.ts:259:15:259:17 | log | (...data: any[]) => void | -| tst.ts:259:19:259:25 | payload | number | -| tst.ts:259:19:259:33 | payload.toFixed | (fractionDigits?: number) => string | -| tst.ts:259:19:259:35 | payload.toFixed() | string | -| tst.ts:259:27:259:33 | toFixed | (fractionDigits?: number) => string | -| tst.ts:260:16:260:19 | kind | "StringContents" | -| tst.ts:260:16:260:40 | kind == ... ntents" | boolean | -| tst.ts:260:25:260:40 | "StringContents" | "StringContents" | -| tst.ts:261:7:261:13 | console | Console | -| tst.ts:261:7:261:17 | console.log | (...data: any[]) => void | -| tst.ts:261:7:261:40 | console ... Case()) | void | -| tst.ts:261:15:261:17 | log | (...data: any[]) => void | -| tst.ts:261:19:261:25 | payload | string | -| tst.ts:261:19:261:37 | payload.toLowerCase | () => string | -| tst.ts:261:19:261:39 | payload ... rCase() | string | -| tst.ts:261:27:261:37 | toLowerCase | () => string | -| tst.ts:266:5:266:10 | number | number | -| tst.ts:267:5:267:10 | string | string | -| tst.ts:268:5:268:11 | boolean | boolean | -| tst.ts:273:7:273:10 | kind | K | -| tst.ts:278:12:278:24 | processRecord | (record: UnionRecord | -| tst.ts:279:5:279:10 | record | UnionRecord | -| tst.ts:279:5:279:22 | record.f(record.v) | void | -| tst.ts:279:14:279:19 | record | UnionRecord | -| tst.ts:279:14:279:21 | record.v | any | -| tst.ts:279:21:279:21 | v | any | -| tst.ts:282:3:282:15 | processRecord | (record: UnionRecord void; } | -| tst.ts:283:5:283:8 | kind | "string" | -| tst.ts:283:11:283:18 | "string" | "string" | -| tst.ts:284:5:284:5 | f | (val: string) => void | -| tst.ts:284:8:286:5 | (val) = ... g\\n } | (val: string) => void | -| tst.ts:284:9:284:11 | val | string | -| tst.ts:285:7:285:13 | console | Console | -| tst.ts:285:7:285:17 | console.log | (...data: any[]) => void | -| tst.ts:285:7:285:36 | console ... Case()) | void | -| tst.ts:285:15:285:17 | log | (...data: any[]) => void | -| tst.ts:285:19:285:21 | val | string | -| tst.ts:285:19:285:33 | val.toUpperCase | () => string | -| tst.ts:285:19:285:35 | val.toUpperCase() | string | -| tst.ts:285:23:285:33 | toUpperCase | () => string | -| tst.ts:289:19:289:22 | args | ["a", number] \| ["b", string] | -| tst.ts:291:9:291:10 | f1 | Func | -| tst.ts:291:20:295:3 | (kind, ... }\\n } | (kind: "a" \| "b", payload: string \| number) => ... | -| tst.ts:291:21:291:24 | kind | "a" \| "b" | -| tst.ts:291:27:291:33 | payload | string \| number | -| tst.ts:292:9:292:12 | kind | "a" \| "b" | -| tst.ts:292:9:292:20 | kind === "a" | boolean | -| tst.ts:292:18:292:20 | "a" | "a" | -| tst.ts:293:7:293:13 | payload | number | -| tst.ts:293:7:293:21 | payload.toFixed | (fractionDigits?: number) => string | -| tst.ts:293:7:293:23 | payload.toFixed() | string | -| tst.ts:293:15:293:21 | toFixed | (fractionDigits?: number) => string | -| tst.ts:298:7:298:9 | key | typeof key | -| tst.ts:298:13:298:18 | Symbol | SymbolConstructor | -| tst.ts:298:13:298:20 | Symbol() | typeof key | -| tst.ts:300:7:300:20 | numberOrString | "hello" \| 42 | -| tst.ts:300:24:300:27 | Math | Math | -| tst.ts:300:24:300:34 | Math.random | () => number | -| tst.ts:300:24:300:36 | Math.random() | number | -| tst.ts:300:24:300:42 | Math.random() < 0.5 | boolean | -| tst.ts:300:24:300:57 | Math.ra ... "hello" | "hello" \| 42 | -| tst.ts:300:29:300:34 | random | () => number | -| tst.ts:300:40:300:42 | 0.5 | 0.5 | -| tst.ts:300:46:300:47 | 42 | 42 | -| tst.ts:300:51:300:57 | "hello" | "hello" | -| tst.ts:302:5:302:7 | obj | { [key]: string \| number; } | -| tst.ts:302:11:304:1 | {\\n [ke ... ring,\\n} | { [key]: string \| number; } | -| tst.ts:303:4:303:6 | key | typeof key | -| tst.ts:303:10:303:23 | numberOrString | "hello" \| 42 | -| tst.ts:306:5:306:19 | typeof obj[key] | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| tst.ts:306:5:306:32 | typeof ... string" | boolean | -| tst.ts:306:12:306:14 | obj | { [key]: string \| number; } | -| tst.ts:306:12:306:19 | obj[key] | string \| number | -| tst.ts:306:16:306:18 | key | typeof key | -| tst.ts:306:25:306:32 | "string" | "string" | -| tst.ts:307:7:307:9 | str | string | -| tst.ts:307:13:307:15 | obj | { [key]: string \| number; } | -| tst.ts:307:13:307:20 | obj[key] | string | -| tst.ts:307:17:307:19 | key | typeof key | -| tst.ts:308:3:308:5 | str | string | -| tst.ts:308:3:308:17 | str.toUpperCase | () => string | -| tst.ts:308:3:308:19 | str.toUpperCase() | string | -| tst.ts:308:7:308:17 | toUpperCase | () => string | -| tst.ts:313:10:313:10 | f | (arg: { produce: (n: string) => T; consume: ... | -| tst.ts:313:15:313:17 | arg | { produce: (n: string) => T; consume: (x: T) =>... | -| tst.ts:314:3:314:9 | produce | (n: string) => T | -| tst.ts:314:12:314:27 | (n: string) => T | (n: string) => T | -| tst.ts:314:13:314:13 | n | string | -| tst.ts:315:3:315:9 | consume | (x: T) => void | -| tst.ts:315:12:315:25 | (x: T) => void | (x: T) => void | -| tst.ts:315:13:315:13 | x | T | -| tst.ts:318:1:318:1 | f | (arg: { produce: (n: string) => T; consume: ... | -| tst.ts:318:1:321:2 | f({\\n p ... se()\\n}) | void | -| tst.ts:318:3:321:1 | {\\n pro ... ase()\\n} | { produce: (n: string) => string; consume: (x: ... | -| tst.ts:319:3:319:9 | produce | (n: string) => string | -| tst.ts:319:12:319:12 | n | string | -| tst.ts:319:12:319:17 | n => n | (n: string) => string | -| tst.ts:319:17:319:17 | n | string | -| tst.ts:320:3:320:9 | consume | (x: string) => string | -| tst.ts:320:12:320:12 | x | string | -| tst.ts:320:12:320:31 | x => x.toLowerCase() | (x: string) => string | -| tst.ts:320:17:320:17 | x | string | -| tst.ts:320:17:320:29 | x.toLowerCase | () => string | -| tst.ts:320:17:320:31 | x.toLowerCase() | string | -| tst.ts:320:19:320:29 | toLowerCase | () => string | -| tst.ts:325:7:325:14 | ErrorMap | { new (entries?: readonly (readonly [string, Er... | -| tst.ts:325:18:325:20 | Map | MapConstructor | -| tst.ts:325:18:325:35 | Map | { new (entries?: readonly (readonly [string, Er... | -| tst.ts:327:7:327:14 | errorMap | Map | -| tst.ts:327:18:327:31 | new ErrorMap() | Map | -| tst.ts:327:22:327:29 | ErrorMap | { new (entries?: readonly (readonly [string, Er... | -| tst.ts:338:7:338:7 | a | "a" \| "b" | -| tst.ts:338:14:338:16 | 'a' | "a" | -| tst.ts:343:3:343:5 | get | () => T | -| tst.ts:343:8:343:14 | () => T | () => T | -| tst.ts:344:3:344:5 | set | (value: T) => void | -| tst.ts:344:8:344:25 | (value: T) => void | (value: T) => void | -| tst.ts:344:9:344:13 | value | T | -| tst.ts:347:7:347:11 | state | State | -| tst.ts:347:30:350:1 | {\\n get ... > { }\\n} | State | -| tst.ts:348:3:348:5 | get | () => number | -| tst.ts:348:8:348:15 | () => 42 | () => number | -| tst.ts:348:14:348:15 | 42 | 42 | -| tst.ts:349:3:349:5 | set | (value: number) => void | -| tst.ts:349:8:349:21 | (value) => { } | (value: number) => void | -| tst.ts:349:9:349:13 | value | number | -| tst.ts:352:7:352:14 | fortyTwo | number | -| tst.ts:352:18:352:22 | state | State | -| tst.ts:352:18:352:26 | state.get | () => number | -| tst.ts:352:18:352:28 | state.get() | number | -| tst.ts:352:24:352:26 | get | () => number | -| tst.ts:356:8:356:18 | tstModuleES | () => "a" \| "b" | -| tst.ts:356:25:356:43 | './tstModuleES.mjs' | any | -| tst.ts:358:1:358:7 | console | Console | -| tst.ts:358:1:358:11 | console.log | (...data: any[]) => void | -| tst.ts:358:1:358:26 | console ... leES()) | void | -| tst.ts:358:9:358:11 | log | (...data: any[]) => void | -| tst.ts:358:13:358:23 | tstModuleES | () => "a" \| "b" | -| tst.ts:358:13:358:25 | tstModuleES() | "a" \| "b" | -| tst.ts:360:10:360:21 | tstModuleCJS | () => "a" \| "b" | -| tst.ts:360:30:360:49 | './tstModuleCJS.cjs' | any | -| tst.ts:362:1:362:7 | console | Console | -| tst.ts:362:1:362:11 | console.log | (...data: any[]) => void | -| tst.ts:362:1:362:27 | console ... eCJS()) | void | -| tst.ts:362:9:362:11 | log | (...data: any[]) => void | -| tst.ts:362:13:362:24 | tstModuleCJS | () => "a" \| "b" | -| tst.ts:362:13:362:26 | tstModuleCJS() | "a" \| "b" | -| tst.ts:368:13:368:13 | A | typeof tstSuffixA.ts | -| tst.ts:368:20:368:33 | './tstSuffixA' | any | -| tst.ts:370:1:370:7 | console | Console | -| tst.ts:370:1:370:11 | console.log | (...data: any[]) => void | -| tst.ts:370:1:370:29 | console ... File()) | void | -| tst.ts:370:9:370:11 | log | (...data: any[]) => void | -| tst.ts:370:13:370:13 | A | typeof tstSuffixA.ts | -| tst.ts:370:13:370:26 | A.resolvedFile | () => "tstSuffixA.ts" | -| tst.ts:370:13:370:28 | A.resolvedFile() | "tstSuffixA.ts" | -| tst.ts:370:15:370:26 | resolvedFile | () => "tstSuffixA.ts" | -| tst.ts:372:13:372:13 | B | typeof tstSuffixB.ios.ts | -| tst.ts:372:20:372:33 | './tstSuffixB' | any | -| tst.ts:374:1:374:7 | console | Console | -| tst.ts:374:1:374:11 | console.log | (...data: any[]) => void | -| tst.ts:374:1:374:29 | console ... File()) | void | -| tst.ts:374:9:374:11 | log | (...data: any[]) => void | -| tst.ts:374:13:374:13 | B | typeof tstSuffixB.ios.ts | -| tst.ts:374:13:374:26 | B.resolvedFile | () => "tstSuffixB.ios.ts" | -| tst.ts:374:13:374:28 | B.resolvedFile() | "tstSuffixB.ios.ts" | -| tst.ts:374:15:374:26 | resolvedFile | () => "tstSuffixB.ios.ts" | -| tst.ts:379:8:379:11 | TS48 | typeof TS48 in tst.ts | -| tst.ts:383:22:383:35 | chooseRandomly | (x: T, y: T) => T | -| tst.ts:383:40:383:40 | x | T | -| tst.ts:383:46:383:46 | y | T | -| tst.ts:385:10:385:10 | a | number | -| tst.ts:385:13:385:13 | b | boolean | -| tst.ts:385:16:385:16 | c | string | -| tst.ts:385:21:385:34 | chooseRandomly | (x: T, y: T) => T | -| tst.ts:385:21:385:73 | chooseR ... bye!"]) | [number, boolean, string] | -| tst.ts:385:36:385:52 | [42, true, "hi!"] | [number, boolean, string] | -| tst.ts:385:37:385:38 | 42 | 42 | -| tst.ts:385:41:385:44 | true | true | -| tst.ts:385:47:385:51 | "hi!" | "hi!" | -| tst.ts:385:55:385:72 | [0, false, "bye!"] | [number, boolean, string] | -| tst.ts:385:56:385:56 | 0 | 0 | -| tst.ts:385:59:385:63 | false | false | -| tst.ts:385:66:385:71 | "bye!" | "bye!" | -| tst.ts:390:8:390:11 | TS49 | typeof TS49 in tst.ts | -| tst.ts:395:9:395:15 | palette | { red: [number, number, number]; green: string;... | -| tst.ts:395:19:399:3 | {\\n r ... 5],\\n } | Record | -| tst.ts:395:19:399:42 | {\\n r ... \| RGB> | { red: [number, number, number]; green: string;... | -| tst.ts:396:5:396:7 | red | [red: number, green: number, blue: number] | -| tst.ts:396:10:396:20 | [255, 0, 0] | string \| RGB | -| tst.ts:396:11:396:13 | 255 | 255 | -| tst.ts:396:16:396:16 | 0 | 0 | -| tst.ts:396:19:396:19 | 0 | 0 | -| tst.ts:397:5:397:9 | green | string | -| tst.ts:397:12:397:20 | "#00ff00" | "#00ff00" | -| tst.ts:398:5:398:8 | bleu | number[] | -| tst.ts:398:11:398:21 | [0, 0, 255] | number[] | -| tst.ts:398:12:398:12 | 0 | 0 | -| tst.ts:398:15:398:15 | 0 | 0 | -| tst.ts:398:18:398:20 | 255 | 255 | -| tst.ts:402:9:402:20 | redComponent | number | -| tst.ts:402:24:402:30 | palette | { red: [number, number, number]; green: string;... | -| tst.ts:402:24:402:34 | palette.red | [red: number, green: number, blue: number] | -| tst.ts:402:24:402:37 | palette.red.at | (index: number) => number | -| tst.ts:402:24:402:40 | palette.red.at(0) | number | -| tst.ts:402:32:402:34 | red | [red: number, green: number, blue: number] | -| tst.ts:402:36:402:37 | at | (index: number) => number | -| tst.ts:402:39:402:39 | 0 | 0 | -| tst.ts:405:5:405:7 | red | number | -| tst.ts:409:5:409:7 | hue | number | -| tst.ts:412:12:412:19 | setColor | (color: RGBObj \| HSVObj) => void | -| tst.ts:412:21:412:25 | color | RGBObj \| HSVObj | -| tst.ts:413:9:413:13 | "hue" | "hue" | -| tst.ts:413:9:413:22 | "hue" in color | boolean | -| tst.ts:413:18:413:22 | color | RGBObj \| HSVObj | -| tst.ts:414:11:414:11 | h | HSVObj | -| tst.ts:414:15:414:19 | color | HSVObj | -| tst.ts:419:9:419:14 | Person | Person | -| tst.ts:420:14:420:17 | name | string | -| tst.ts:422:5:424:5 | constru ... ;\\n } | any | -| tst.ts:422:17:422:20 | name | string | -| tst.ts:423:7:423:15 | this.name | string | -| tst.ts:423:7:423:22 | this.name = name | string | -| tst.ts:423:12:423:15 | name | string | -| tst.ts:423:19:423:22 | name | string | -| tst.ts:430:8:430:11 | TS50 | typeof TS50 in tst.ts | -| tst.ts:432:33:432:36 | args | Args | -| tst.ts:433:68:433:71 | args | Args | -| tst.ts:435:15:435:24 | methodName | string | -| tst.ts:435:28:435:33 | String | StringConstructor | -| tst.ts:435:28:435:47 | String(context.name) | string | -| tst.ts:435:35:435:46 | context.name | string \| symbol | -| tst.ts:435:43:435:46 | name | string \| symbol | -| tst.ts:437:51:437:54 | args | Args | -| tst.ts:438:13:438:19 | console | Console | -| tst.ts:438:13:438:23 | console.log | (...data: any[]) => void | -| tst.ts:438:13:438:64 | console ... me}'.`) | void | -| tst.ts:438:21:438:23 | log | (...data: any[]) => void | -| tst.ts:438:25:438:63 | `LOG: E ... ame}'.` | string | -| tst.ts:438:26:438:47 | LOG: En ... ethod ' | any | -| tst.ts:438:50:438:59 | methodName | string | -| tst.ts:438:61:438:62 | '. | any | -| tst.ts:439:19:439:24 | result | any | -| tst.ts:439:28:439:38 | target.call | (this: Function, thisArg: any, ...argArray: any... | -| tst.ts:439:28:439:53 | target. ... ..args) | any | -| tst.ts:439:35:439:38 | call | (this: Function, thisArg: any, ...argArray: any... | -| tst.ts:439:49:439:52 | args | Args | -| tst.ts:440:13:440:19 | console | Console | -| tst.ts:440:13:440:23 | console.log | (...data: any[]) => void | -| tst.ts:440:13:440:63 | console ... me}'.`) | void | -| tst.ts:440:21:440:23 | log | (...data: any[]) => void | -| tst.ts:440:25:440:62 | `LOG: E ... ame}'.` | string | -| tst.ts:440:26:440:46 | LOG: Ex ... ethod ' | any | -| tst.ts:440:49:440:58 | methodName | string | -| tst.ts:440:60:440:61 | '. | any | -| tst.ts:441:20:441:25 | result | any | -| tst.ts:447:11:447:16 | Person | Person | -| tst.ts:448:9:448:12 | name | string | -| tst.ts:449:9:451:9 | constru ... } | any | -| tst.ts:449:21:449:24 | name | string | -| tst.ts:450:13:450:21 | this.name | string | -| tst.ts:450:13:450:28 | this.name = name | string | -| tst.ts:450:18:450:21 | name | string | -| tst.ts:450:25:450:28 | name | string | -| tst.ts:453:10:453:25 | loggedMethod("") | (this: unknown, args_0: () => number, args_1: C... | -| tst.ts:453:23:453:24 | "" | "" | -| tst.ts:454:9:454:13 | greet | () => number | -| tst.ts:454:9:457:9 | greet() ... } | () => number | -| tst.ts:455:13:455:19 | console | Console | -| tst.ts:455:13:455:23 | console.log | (...data: any[]) => void | -| tst.ts:455:13:455:58 | console ... ame}.`) | void | -| tst.ts:455:21:455:23 | log | (...data: any[]) => void | -| tst.ts:455:25:455:57 | `Hello, ... name}.` | string | -| tst.ts:455:26:455:43 | Hello, my name is | any | -| tst.ts:455:46:455:54 | this.name | string | -| tst.ts:455:51:455:54 | name | string | -| tst.ts:455:56:455:56 | . | any | -| tst.ts:456:20:456:20 | 2 | 2 | -| tst.ts:460:11:460:11 | p | number | -| tst.ts:460:15:460:32 | new Person("John") | Person | -| tst.ts:460:15:460:38 | new Per ... ).greet | () => number | -| tst.ts:460:15:460:40 | new Per ... greet() | number | -| tst.ts:460:19:460:24 | Person | typeof Person in tst.ts:430 | -| tst.ts:460:26:460:31 | "John" | "John" | -| tst.ts:460:34:460:38 | greet | () => number | -| tst.ts:462:22:462:38 | myConstIdFunction | (args: T) => T | -| tst.ts:462:75:462:78 | args | T | -| tst.ts:465:11:465:13 | foo | readonly ["a", "b", "c"] | -| tst.ts:465:17:465:33 | myConstIdFunction | (args: T) => T | -| tst.ts:465:17:465:50 | myConst ... ,"c"]) | readonly ["a", "b", "c"] | -| tst.ts:465:35:465:49 | ["a", "b" ,"c"] | readonly ["a", "b", "c"] | -| tst.ts:465:36:465:38 | "a" | "a" | -| tst.ts:465:41:465:43 | "b" | "b" | -| tst.ts:465:46:465:48 | "c" | "c" | -| tst.ts:467:11:467:11 | b | "b" | -| tst.ts:467:15:467:17 | foo | readonly ["a", "b", "c"] | -| tst.ts:467:15:467:20 | foo[1] | "b" | -| tst.ts:467:19:467:19 | 1 | 1 | -| tst.ts:472:8:472:11 | TS52 | typeof TS52 in tst.ts | -| tst.ts:473:11:473:19 | SomeClass | SomeClass | -| tst.ts:474:10:474:36 | ((_targ ... => {}) | (_target: undefined, _context: ClassFieldDecora... | -| tst.ts:474:11:474:35 | (_targe ... ) => {} | (_target: undefined, _context: ClassFieldDecora... | -| tst.ts:474:12:474:18 | _target | undefined | -| tst.ts:474:21:474:28 | _context | ClassFieldDecoratorContext &... | -| tst.ts:475:9:475:11 | foo | number | -| tst.ts:475:15:475:17 | 123 | 123 | -| tst.ts:478:5:478:11 | console | Console | -| tst.ts:478:5:478:15 | console.log | (...data: any[]) => void | -| tst.ts:478:5:478:43 | console ... adata]) | void | -| tst.ts:478:13:478:15 | log | (...data: any[]) => void | -| tst.ts:478:17:478:25 | SomeClass | typeof SomeClass in tst.ts:472 | -| tst.ts:478:17:478:42 | SomeCla ... tadata] | DecoratorMetadataObject | -| tst.ts:478:27:478:32 | Symbol | SymbolConstructor | -| tst.ts:478:27:478:41 | Symbol.metadata | typeof metadata | -| tst.ts:478:34:478:41 | metadata | typeof metadata | -| tst.ts:483:5:483:11 | console | Console | -| tst.ts:483:5:483:15 | console.log | (...data: any[]) => void | -| tst.ts:483:5:483:59 | console ... tring>) | void | -| tst.ts:483:13:483:15 | log | (...data: any[]) => void | -| tst.ts:483:17:483:34 | ["hello", "world"] | Pair3 | -| tst.ts:483:17:483:58 | ["hello ... string> | [first: string, string] | -| tst.ts:483:18:483:24 | "hello" | "hello" | -| tst.ts:483:27:483:33 | "world" | "world" | -| tst.ts:486:8:486:11 | TS54 | typeof TS54 in tst.ts | -| tst.ts:487:48:487:53 | colors | C[] | -| tst.ts:488:12:488:17 | colors | C[] | -| tst.ts:488:12:488:20 | colors[0] | C | -| tst.ts:488:19:488:19 | 0 | 0 | -| tst.ts:491:3:491:57 | createS ... ellow") | "red" \| "green" \| "yellow" | -| tst.ts:491:21:491:46 | ["red", ... green"] | ("red" \| "green" \| "yellow")[] | -| tst.ts:491:22:491:26 | "red" | "red" | -| tst.ts:491:29:491:36 | "yellow" | "yellow" | -| tst.ts:491:39:491:45 | "green" | "green" | -| tst.ts:491:49:491:56 | "yellow" | "yellow" | -| tst.ts:493:9:493:13 | myObj | Partial> | -| tst.ts:493:17:493:22 | Object | ObjectConstructor | -| tst.ts:493:17:493:30 | Object.groupBy | (items: Iterable, ... | -| tst.ts:493:17:495:4 | Object. ... ";\\n }) | Partial> | -| tst.ts:493:24:493:30 | groupBy | (items: Iterable, ... | -| tst.ts:493:32:493:49 | [0, 1, 2, 3, 4, 5] | Iterable | -| tst.ts:493:33:493:33 | 0 | 0 | -| tst.ts:493:36:493:36 | 1 | 1 | -| tst.ts:493:39:493:39 | 2 | 2 | -| tst.ts:493:42:493:42 | 3 | 3 | -| tst.ts:493:45:493:45 | 4 | 4 | -| tst.ts:493:48:493:48 | 5 | 5 | -| tst.ts:493:52:495:3 | (num, i ... d";\\n } | (num: number, index: number) => "even" \| "odd" | -| tst.ts:493:53:493:55 | num | number | -| tst.ts:493:58:493:62 | index | number | -| tst.ts:494:12:494:14 | num | number | -| tst.ts:494:12:494:18 | num % 2 | number | -| tst.ts:494:12:494:24 | num % 2 === 0 | boolean | -| tst.ts:494:12:494:40 | num % 2 ... : "odd" | "even" \| "odd" | -| tst.ts:494:18:494:18 | 2 | 2 | -| tst.ts:494:24:494:24 | 0 | 0 | -| tst.ts:494:28:494:33 | "even" | "even" | -| tst.ts:494:36:494:40 | "odd" | "odd" | -| tst.ts:498:8:498:11 | TS55 | typeof TS55 in tst.ts | -| tst.ts:499:9:499:15 | strings | string[] | -| tst.ts:499:19:499:32 | (["foo", 123]) | (string \| number)[] | -| tst.ts:499:19:500:11 | (["foo" ... .filter | { (predicate: (value... | -| tst.ts:499:19:500:39 | (["foo" ... tring") | string[] | -| tst.ts:499:20:499:31 | ["foo", 123] | (string \| number)[] | -| tst.ts:499:21:499:25 | "foo" | "foo" | -| tst.ts:499:28:499:30 | 123 | 123 | -| tst.ts:500:6:500:11 | filter | { (predicate: (value... | -| tst.ts:500:13:500:13 | s | string \| number | -| tst.ts:500:13:500:38 | s => ty ... string" | (s: string \| number) => s is string | -| tst.ts:500:18:500:25 | typeof s | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| tst.ts:500:18:500:38 | typeof ... string" | boolean | -| tst.ts:500:25:500:25 | s | string \| number | -| tst.ts:500:31:500:38 | "string" | "string" | -| tst.ts:502:14:502:16 | str | string | -| tst.ts:502:21:502:27 | strings | string[] | -| tst.ts:503:5:503:7 | str | string | -| tst.ts:503:5:503:19 | str.toLowerCase | () => string | -| tst.ts:503:5:503:21 | str.toLowerCase() | string | -| tst.ts:503:9:503:19 | toLowerCase | () => string | -| tst.ts:506:12:506:13 | f1 | (obj: Record, key: string) => ... | -| tst.ts:506:15:506:17 | obj | Record | -| tst.ts:506:45:506:47 | key | string | -| tst.ts:507:9:507:23 | typeof obj[key] | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| tst.ts:507:9:507:36 | typeof ... string" | boolean | -| tst.ts:507:16:507:18 | obj | Record | -| tst.ts:507:16:507:23 | obj[key] | unknown | -| tst.ts:507:20:507:22 | key | string | -| tst.ts:507:29:507:36 | "string" | "string" | -| tst.ts:508:11:508:13 | str | string | -| tst.ts:508:17:508:19 | obj | Record | -| tst.ts:508:17:508:24 | obj[key] | string | -| tst.ts:508:17:508:36 | obj[key].toUpperCase | () => string | -| tst.ts:508:17:508:38 | obj[key ... rCase() | string | -| tst.ts:508:21:508:23 | key | string | -| tst.ts:508:26:508:36 | toUpperCase | () => string | -| tst.ts:513:11:513:14 | TS57 | typeof TS57 in tst.ts | -| tst.ts:514:17:514:17 | a | symbol | -| tst.ts:515:16:515:16 | A | A | -| tst.ts:516:7:516:24 | [a]() { return 1 } | () => number | -| tst.ts:516:8:516:8 | a | symbol | -| tst.ts:516:22:516:22 | 1 | 1 | -| tst.ts:519:17:519:18 | e1 | () => number | -| tstModuleCJS.cts:1:17:1:28 | tstModuleCJS | () => "a" \| "b" | -| tstModuleCJS.cts:2:12:2:15 | Math | Math | -| tstModuleCJS.cts:2:12:2:22 | Math.random | () => number | -| tstModuleCJS.cts:2:12:2:24 | Math.random() | number | -| tstModuleCJS.cts:2:12:2:30 | Math.random() > 0.5 | boolean | -| tstModuleCJS.cts:2:12:2:42 | Math.ra ... ' : 'b' | "a" \| "b" | -| tstModuleCJS.cts:2:17:2:22 | random | () => number | -| tstModuleCJS.cts:2:28:2:30 | 0.5 | 0.5 | -| tstModuleCJS.cts:2:34:2:36 | 'a' | "a" | -| tstModuleCJS.cts:2:40:2:42 | 'b' | "b" | -| tstModuleES.mts:1:25:1:35 | tstModuleES | () => "a" \| "b" | -| tstModuleES.mts:2:12:2:15 | Math | Math | -| tstModuleES.mts:2:12:2:22 | Math.random | () => number | -| tstModuleES.mts:2:12:2:24 | Math.random() | number | -| tstModuleES.mts:2:12:2:30 | Math.random() > 0.5 | boolean | -| tstModuleES.mts:2:12:2:42 | Math.ra ... ' : 'b' | "a" \| "b" | -| tstModuleES.mts:2:17:2:22 | random | () => number | -| tstModuleES.mts:2:28:2:30 | 0.5 | 0.5 | -| tstModuleES.mts:2:34:2:36 | 'a' | "a" | -| tstModuleES.mts:2:40:2:42 | 'b' | "b" | -| tstSuffixA.ts:1:17:1:28 | resolvedFile | () => "tstSuffixA.ts" | -| tstSuffixA.ts:2:12:2:26 | 'tstSuffixA.ts' | "tstSuffixA.ts" | -| tstSuffixB.ios.ts:1:17:1:28 | resolvedFile | () => "tstSuffixB.ios.ts" | -| tstSuffixB.ios.ts:2:12:2:30 | 'tstSuffixB.ios.ts' | "tstSuffixB.ios.ts" | -| tstSuffixB.ts:1:17:1:28 | resolvedFile | () => "tstSuffixB.ts" | -| tstSuffixB.ts:2:12:2:26 | 'tstSuffixB.ts' | "tstSuffixB.ts" | -| type_alias.ts:3:5:3:5 | b | boolean | -| type_alias.ts:7:5:7:5 | c | ValueOrArray | -| type_alias.ts:14:9:14:32 | [proper ... ]: Json | any | -| type_alias.ts:14:10:14:17 | property | string | -| type_alias.ts:17:5:17:8 | json | Json | -| type_alias.ts:21:18:21:35 | [key: string]: any | any | -| type_alias.ts:21:19:21:21 | key | string | -| type_alias.ts:23:7:23:12 | myNode | VirtualNode | -| type_alias.ts:24:5:27:5 | ["div", ... ]\\n ] | VirtualNode | -| type_alias.ts:24:6:24:10 | "div" | "div" | -| type_alias.ts:24:13:24:28 | { id: "parent" } | string \| { [key: string]: any; } | -| type_alias.ts:24:15:24:16 | id | string | -| type_alias.ts:24:19:24:26 | "parent" | "parent" | -| type_alias.ts:25:9:25:61 | ["div", ... child"] | VirtualNode | -| type_alias.ts:25:10:25:14 | "div" | "div" | -| type_alias.ts:25:17:25:37 | { id: " ... hild" } | string \| { [key: string]: any; } | -| type_alias.ts:25:19:25:20 | id | string | -| type_alias.ts:25:23:25:35 | "first-child" | "first-child" | -| type_alias.ts:25:40:25:60 | "I'm th ... child" | "I'm the first child" | -| type_alias.ts:26:9:26:63 | ["div", ... child"] | VirtualNode | -| type_alias.ts:26:10:26:14 | "div" | "div" | -| type_alias.ts:26:17:26:38 | { id: " ... hild" } | string \| { [key: string]: any; } | -| type_alias.ts:26:19:26:20 | id | string | -| type_alias.ts:26:23:26:36 | "second-child" | "second-child" | -| type_alias.ts:26:41:26:62 | "I'm th ... child" | "I'm the second child" | -| type_definition_objects.ts:1:13:1:17 | dummy | typeof dummy.ts | -| type_definition_objects.ts:1:24:1:32 | "./dummy" | any | -| type_definition_objects.ts:3:14:3:14 | C | C | -| type_definition_objects.ts:4:5:4:12 | classObj | typeof C in type_definition_objects.ts | -| type_definition_objects.ts:4:16:4:16 | C | typeof C in type_definition_objects.ts | -| type_definition_objects.ts:6:13:6:13 | E | E | -| type_definition_objects.ts:7:5:7:11 | enumObj | typeof E in type_definition_objects.ts | -| type_definition_objects.ts:7:15:7:15 | E | typeof E in type_definition_objects.ts | -| type_definition_objects.ts:9:18:9:18 | N | typeof N in type_definition_objects.ts | -| type_definition_objects.ts:10:5:10:16 | namespaceObj | typeof N in type_definition_objects.ts | -| type_definition_objects.ts:10:20:10:20 | N | typeof N in type_definition_objects.ts | -| type_definitions.ts:1:13:1:17 | dummy | typeof dummy.ts | -| type_definitions.ts:1:24:1:32 | "./dummy" | any | -| type_definitions.ts:4:3:4:3 | x | S | -| type_definitions.ts:6:5:6:5 | i | I | -| type_definitions.ts:8:7:8:7 | C | C | -| type_definitions.ts:9:3:9:3 | x | T | -| type_definitions.ts:11:5:11:5 | c | C | -| type_definitions.ts:13:6:13:10 | Color | Color | -| type_definitions.ts:16:5:16:9 | color | Color | -| type_definitions.ts:18:6:18:22 | EnumWithOneMember | EnumWithOneMember | -| type_definitions.ts:19:5:19:5 | e | EnumWithOneMember | -| type_definitions.ts:22:5:22:23 | aliasForNumberArray | Alias | -getTypeDefinitionType -| badTypes.ts:5:1:5:29 | interfa ... is.B {} | A | -| badTypes.ts:6:1:6:24 | type T ... ar.bar; | any | -| tst.ts:54:1:56:1 | interfa ... mber;\\n} | NonAbstractDummy | -| tst.ts:58:1:60:1 | interfa ... mber;\\n} | HasArea | -| tst.ts:65:1:65:54 | type My ... true}; | MyUnion | -| tst.ts:68:1:68:49 | type My ... true}; | MyUnion2 | -| tst.ts:73:3:76:3 | interfa ... n);\\n } | ThingI | -| tst.ts:78:10:88:3 | class T ... }\\n } | Thing | -| tst.ts:91:3:95:3 | class S ... }\\n } | Super | -| tst.ts:97:3:101:3 | class S ... }\\n } | Sub | -| tst.ts:116:3:129:3 | class F ... }\\n } | Foo | -| tst.ts:140:3:142:47 | type Sh ... mber }; | Shape | -| tst.ts:152:5:156:5 | interfa ... ;\\n } | Colors | -| tst.ts:165:5:167:5 | interfa ... ;\\n } | Foo | -| tst.ts:171:5:173:5 | interfa ... ;\\n } | Data | -| tst.ts:179:3:192:3 | class F ... \\n } | Foo | -| tst.ts:197:3:197:36 | type A ... ring>>; | string | -| tst.ts:200:3:200:45 | type B ... ber>>>; | number | -| tst.ts:203:3:203:46 | type C ... mber>>; | C | -| tst.ts:205:10:208:3 | interfa ... ng;\\n } | Success | -| tst.ts:210:10:213:3 | interfa ... ng;\\n } | Error | -| tst.ts:222:3:234:3 | class P ... }\\n } | Person | -| tst.ts:241:3:241:15 | class Base {} | Base | -| tst.ts:243:3:250:3 | class D ... }\\n } | Derived | -| tst.ts:252:3:254:50 | type Ac ... ring }; | Action | -| tst.ts:265:3:269:3 | interfa ... an;\\n } | TypeMap | -| tst.ts:271:3:276:7 | type Un ... }[P]; | UnionRecord

| -| tst.ts:289:3:289:63 | type Fu ... > void; | Func | -| tst.ts:331:1:334:14 | type Fi ... never; | FirstString | -| tst.ts:336:1:336:51 | type F ... lean]>; | "a" \| "b" | -| tst.ts:342:1:345:1 | interfa ... void;\\n} | State | -| tst.ts:381:5:381:73 | type So ... never; | 100 | -| tst.ts:391:3:391:41 | type Co ... "blue"; | Colors | -| tst.ts:393:3:393:56 | type RG ... umber]; | RGB | -| tst.ts:404:3:406:3 | interfa ... er;\\n } | RGBObj | -| tst.ts:408:3:410:3 | interfa ... er;\\n } | HSVObj | -| tst.ts:419:3:425:3 | class P ... }\\n } | Person | -| tst.ts:447:5:458:5 | class P ... }\\n } | Person | -| tst.ts:473:5:476:5 | class S ... ;\\n } | SomeClass | -| tst.ts:481:5:481:34 | type Pa ... T, T]; | Pair3 | -| tst.ts:515:10:517:3 | class A ... };\\n } | A | -| type_alias.ts:1:1:1:17 | type B = boolean; | boolean | -| type_alias.ts:5:1:5:50 | type Va ... ay>; | ValueOrArray | -| type_alias.ts:9:1:15:13 | type Js ... Json[]; | Json | -| type_alias.ts:19:1:21:57 | type Vi ... ode[]]; | VirtualNode | -| type_definition_objects.ts:3:8:3:17 | class C {} | C | -| type_definition_objects.ts:6:8:6:16 | enum E {} | E | -| type_definitions.ts:3:1:5:1 | interfa ... x: S;\\n} | I | -| type_definitions.ts:8:1:10:1 | class C ... x: T\\n} | C | -| type_definitions.ts:13:1:15:1 | enum Co ... blue\\n} | Color | -| type_definitions.ts:18:1:18:33 | enum En ... ember } | EnumWithOneMember | -| type_definitions.ts:21:1:21:20 | type Alias = T[]; | Alias | -getTypeExprType -| badTypes.ts:5:11:5:11 | A | A | -| badTypes.ts:6:6:6:6 | T | any | -| badTypes.ts:6:10:6:23 | typeof var.bar | any | -| badTypes.ts:6:17:6:19 | var | any | -| badTypes.ts:6:21:6:23 | bar | any | -| boolean-type.ts:3:12:3:15 | true | true | -| boolean-type.ts:4:12:4:15 | true | true | -| boolean-type.ts:4:12:4:22 | true \| true | true | -| boolean-type.ts:4:19:4:22 | true | true | -| boolean-type.ts:6:13:6:17 | false | false | -| boolean-type.ts:7:13:7:17 | false | false | -| boolean-type.ts:7:13:7:25 | false \| false | false | -| boolean-type.ts:7:21:7:25 | false | false | -| boolean-type.ts:9:15:9:21 | boolean | boolean | -| boolean-type.ts:10:15:10:18 | true | true | -| boolean-type.ts:10:15:10:26 | true \| false | boolean | -| boolean-type.ts:10:22:10:26 | false | false | -| boolean-type.ts:11:15:11:19 | false | false | -| boolean-type.ts:11:15:11:26 | false \| true | boolean | -| boolean-type.ts:11:23:11:26 | true | true | -| boolean-type.ts:13:15:13:21 | boolean | boolean | -| boolean-type.ts:13:15:13:31 | boolean \| boolean | boolean | -| boolean-type.ts:13:25:13:31 | boolean | boolean | -| boolean-type.ts:14:15:14:21 | boolean | boolean | -| boolean-type.ts:14:15:14:28 | boolean \| true | boolean | -| boolean-type.ts:14:25:14:28 | true | true | -| boolean-type.ts:15:15:15:19 | false | false | -| boolean-type.ts:15:15:15:29 | false \| boolean | boolean | -| boolean-type.ts:15:23:15:29 | boolean | boolean | -| middle-rest.ts:1:10:1:39 | [boolea ... number] | [boolean, ...string[], number] | -| middle-rest.ts:1:11:1:17 | boolean | boolean | -| middle-rest.ts:1:20:1:30 | ...string[] | string | -| middle-rest.ts:1:23:1:28 | string | string | -| middle-rest.ts:1:23:1:30 | string[] | string[] | -| middle-rest.ts:1:33:1:38 | number | number | -| tst.ts:3:13:3:18 | number | number | -| tst.ts:9:13:9:18 | string | string | -| tst.ts:14:20:14:25 | string | string | -| tst.ts:14:31:14:36 | string | string | -| tst.ts:14:40:14:45 | string | string | -| tst.ts:16:17:16:22 | number | number | -| tst.ts:16:28:16:33 | number | number | -| tst.ts:16:37:16:42 | number | number | -| tst.ts:20:29:20:34 | string | string | -| tst.ts:24:12:24:17 | number | number | -| tst.ts:24:12:24:19 | number[] | number[] | -| tst.ts:26:15:26:24 | () => void | () => void | -| tst.ts:26:21:26:24 | void | void | -| tst.ts:27:20:27:28 | undefined | undefined | -| tst.ts:28:15:28:18 | null | null | -| tst.ts:29:16:29:26 | () => never | () => never | -| tst.ts:29:22:29:26 | never | never | -| tst.ts:30:17:30:22 | symbol | symbol | -| tst.ts:31:25:31:37 | unique symbol | typeof uniqueSymbolType | -| tst.ts:32:17:32:22 | object | object | -| tst.ts:33:19:33:24 | string | string | -| tst.ts:33:19:33:38 | string & {x: string} | string & { x: string; } | -| tst.ts:33:28:33:38 | {x: string} | { x: string; } | -| tst.ts:33:32:33:37 | string | string | -| tst.ts:34:12:34:27 | [number, string] | [number, string] | -| tst.ts:34:13:34:18 | number | number | -| tst.ts:34:21:34:26 | string | string | -| tst.ts:36:31:36:55 | [number ... umber?] | [number, string, number?] | -| tst.ts:36:32:36:37 | number | number | -| tst.ts:36:40:36:45 | string | string | -| tst.ts:36:48:36:53 | number | number | -| tst.ts:36:48:36:54 | number? | number | -| tst.ts:37:17:37:18 | [] | [] | -| tst.ts:38:27:38:47 | [number ... ring[]] | [number, ...string[]] | -| tst.ts:38:28:38:33 | number | number | -| tst.ts:38:36:38:46 | ...string[] | string | -| tst.ts:38:39:38:44 | string | string | -| tst.ts:38:39:38:46 | string[] | string[] | -| tst.ts:39:39:39:68 | [number ... mber[]] | [number, string?, ...number[]] | -| tst.ts:39:40:39:45 | number | number | -| tst.ts:39:48:39:53 | string | string | -| tst.ts:39:48:39:54 | string? | string | -| tst.ts:39:57:39:67 | ...number[] | number | -| tst.ts:39:60:39:65 | number | number | -| tst.ts:39:60:39:67 | number[] | number[] | -| tst.ts:40:18:40:24 | unknown | unknown | -| tst.ts:49:15:49:20 | string | string | -| tst.ts:54:11:54:26 | NonAbstractDummy | NonAbstractDummy | -| tst.ts:55:14:55:19 | number | number | -| tst.ts:58:11:58:17 | HasArea | HasArea | -| tst.ts:59:14:59:19 | number | number | -| tst.ts:63:11:63:36 | abstrac ... HasArea | abstract new () => HasArea | -| tst.ts:63:30:63:36 | HasArea | HasArea | -| tst.ts:65:6:65:12 | MyUnion | MyUnion | -| tst.ts:65:16:65:30 | {myUnion: true} | { myUnion: true; } | -| tst.ts:65:16:65:53 | {myUnio ... : true} | { myUnion: true; } \| { stillMyUnion: true; } | -| tst.ts:65:26:65:29 | true | true | -| tst.ts:65:34:65:53 | {stillMyUnion: true} | { stillMyUnion: true; } | -| tst.ts:65:49:65:52 | true | true | -| tst.ts:66:13:66:19 | MyUnion | MyUnion | -| tst.ts:68:6:68:13 | MyUnion2 | MyUnion2 | -| tst.ts:68:17:68:23 | MyUnion | MyUnion | -| tst.ts:68:17:68:48 | MyUnion ... : true} | MyUnion \| { yetAnotherType: true; } | -| tst.ts:68:27:68:48 | {yetAno ... : true} | { yetAnotherType: true; } | -| tst.ts:68:44:68:47 | true | true | -| tst.ts:69:13:69:20 | MyUnion2 | MyUnion2 | -| tst.ts:73:13:73:18 | ThingI | ThingI | -| tst.ts:74:17:74:22 | number | number | -| tst.ts:75:21:75:26 | number | number | -| tst.ts:75:21:75:45 | number ... boolean | string \| number \| boolean | -| tst.ts:75:30:75:35 | string | string | -| tst.ts:75:39:75:45 | boolean | boolean | -| tst.ts:78:33:78:38 | ThingI | ThingI | -| tst.ts:81:17:81:22 | number | number | -| tst.ts:85:21:85:26 | string | string | -| tst.ts:85:21:85:45 | string ... boolean | string \| number \| boolean | -| tst.ts:85:30:85:35 | number | number | -| tst.ts:85:39:85:45 | boolean | boolean | -| tst.ts:92:15:92:20 | number | number | -| tst.ts:98:24:98:29 | number | number | -| tst.ts:104:19:104:24 | string | string | -| tst.ts:104:29:104:34 | hello | any | -| tst.ts:104:37:104:42 | string | string | -| tst.ts:109:22:109:27 | number | number | -| tst.ts:109:29:109:29 | - | any | -| tst.ts:109:32:109:37 | number | number | -| tst.ts:109:39:109:39 | - | any | -| tst.ts:109:42:109:47 | number | number | -| tst.ts:110:19:110:25 | `1-2-3` | "1-2-3" | -| tst.ts:110:19:110:25 | `1-2-3` | any | -| tst.ts:111:22:111:27 | number | number | -| tst.ts:111:29:111:32 | -2-3 | any | -| tst.ts:117:20:117:25 | number | number | -| tst.ts:121:23:121:28 | number | number | -| tst.ts:133:21:133:27 | unknown | unknown | -| tst.ts:140:8:140:12 | Shape | Shape | -| tst.ts:141:7:142:46 | \| { kin ... umber } | { kind: "circle"; radius: number; } \| { kind: "... | -| tst.ts:141:9:141:42 | { kind: ... umber } | { kind: "circle"; radius: number; } | -| tst.ts:141:17:141:24 | "circle" | "circle" | -| tst.ts:141:35:141:40 | number | number | -| tst.ts:142:9:142:46 | { kind: ... umber } | { kind: "square"; sideLength: number; } | -| tst.ts:142:17:142:24 | "square" | "square" | -| tst.ts:142:39:142:44 | number | number | -| tst.ts:144:24:144:28 | Shape | Shape | -| tst.ts:144:32:144:37 | number | number | -| tst.ts:152:15:152:20 | Colors | Colors | -| tst.ts:153:13:153:18 | symbol | symbol | -| tst.ts:153:22:153:27 | number | number | -| tst.ts:154:13:154:18 | string | string | -| tst.ts:154:22:154:27 | string | string | -| tst.ts:155:13:155:18 | number | number | -| tst.ts:155:22:155:28 | boolean | boolean | -| tst.ts:158:17:158:22 | Colors | Colors | -| tst.ts:165:15:165:17 | Foo | Foo | -| tst.ts:166:14:166:17 | foo- | any | -| tst.ts:166:20:166:25 | number | number | -| tst.ts:166:31:166:36 | number | number | -| tst.ts:168:15:168:17 | Foo | Foo | -| tst.ts:171:15:171:18 | Data | Data | -| tst.ts:172:17:172:22 | string | string | -| tst.ts:172:17:172:31 | string \| symbol | string \| symbol | -| tst.ts:172:26:172:31 | symbol | symbol | -| tst.ts:172:35:172:41 | boolean | boolean | -| tst.ts:175:17:175:20 | Data | Data | -| tst.ts:197:8:197:8 | A | string | -| tst.ts:197:12:197:18 | Awaited | Awaited | -| tst.ts:197:12:197:35 | Awaited ... tring>> | string | -| tst.ts:197:20:197:26 | Promise | Promise | -| tst.ts:197:20:197:34 | Promise | Promise | -| tst.ts:197:28:197:33 | string | string | -| tst.ts:200:8:200:8 | B | number | -| tst.ts:200:12:200:18 | Awaited | Awaited | -| tst.ts:200:12:200:44 | Awaited ... mber>>> | number | -| tst.ts:200:20:200:26 | Promise | Promise | -| tst.ts:200:20:200:43 | Promise ... umber>> | Promise> | -| tst.ts:200:28:200:34 | Promise | Promise | -| tst.ts:200:28:200:42 | Promise | Promise | -| tst.ts:200:36:200:41 | number | number | -| tst.ts:203:8:203:8 | C | C | -| tst.ts:203:12:203:18 | Awaited | Awaited | -| tst.ts:203:12:203:45 | Awaited ... umber>> | number \| boolean | -| tst.ts:203:20:203:26 | boolean | boolean | -| tst.ts:203:20:203:44 | boolean ... number> | boolean \| Promise | -| tst.ts:203:30:203:36 | Promise | Promise | -| tst.ts:203:30:203:44 | Promise | Promise | -| tst.ts:203:38:203:43 | number | number | -| tst.ts:205:20:205:26 | Success | Success | -| tst.ts:206:14:206:19 | string | string | -| tst.ts:206:21:206:27 | Success | any | -| tst.ts:207:11:207:16 | string | string | -| tst.ts:210:20:210:24 | Error | Error | -| tst.ts:211:16:211:21 | string | string | -| tst.ts:211:23:211:27 | Error | any | -| tst.ts:212:16:212:21 | string | string | -| tst.ts:215:30:215:36 | Success | Success | -| tst.ts:215:30:215:44 | Success \| Error | Success \| Error | -| tst.ts:215:40:215:44 | Error | Error | -| tst.ts:223:12:223:17 | string | string | -| tst.ts:224:23:224:28 | string | string | -| tst.ts:228:19:228:25 | unknown | unknown | -| tst.ts:252:8:252:13 | Action | Action | -| tst.ts:253:5:254:49 | \| { kin ... tring } | { kind: "NumberContents"; payload: number; } \| ... | -| tst.ts:253:7:253:49 | { kind: ... umber } | { kind: "NumberContents"; payload: number; } | -| tst.ts:253:15:253:30 | "NumberContents" | "NumberContents" | -| tst.ts:253:42:253:47 | number | number | -| tst.ts:254:7:254:49 | { kind: ... tring } | { kind: "StringContents"; payload: string; } | -| tst.ts:254:15:254:30 | "StringContents" | "StringContents" | -| tst.ts:254:42:254:47 | string | string | -| tst.ts:256:34:256:39 | Action | Action | -| tst.ts:265:13:265:19 | TypeMap | TypeMap | -| tst.ts:266:13:266:18 | number | number | -| tst.ts:267:13:267:18 | string | string | -| tst.ts:268:14:268:20 | boolean | boolean | -| tst.ts:271:8:271:18 | UnionRecord | UnionRecord

| -| tst.ts:271:20:271:20 | P | P | -| tst.ts:271:30:271:42 | keyof TypeMap | keyof TypeMap | -| tst.ts:271:36:271:42 | TypeMap | TypeMap | -| tst.ts:272:6:272:6 | K | K | -| tst.ts:272:11:272:11 | P | P | -| tst.ts:273:13:273:13 | K | K | -| tst.ts:274:14:274:20 | TypeMap | TypeMap | -| tst.ts:274:22:274:22 | K | K | -| tst.ts:274:29:274:32 | void | void | -| tst.ts:276:5:276:5 | P | P | -| tst.ts:278:26:278:26 | K | K | -| tst.ts:278:36:278:48 | keyof TypeMap | keyof TypeMap | -| tst.ts:278:42:278:48 | TypeMap | TypeMap | -| tst.ts:278:59:278:69 | UnionRecord | UnionRecord

| -| tst.ts:278:59:278:72 | UnionRecord | UnionRecord | -| tst.ts:278:71:278:71 | K | K | -| tst.ts:289:8:289:11 | Func | Func | -| tst.ts:289:25:289:37 | ["a", number] | ["a", number] | -| tst.ts:289:25:289:53 | ["a", n ... string] | ["a", number] \| ["b", string] | -| tst.ts:289:26:289:28 | "a" | "a" | -| tst.ts:289:31:289:36 | number | number | -| tst.ts:289:41:289:53 | ["b", string] | ["b", string] | -| tst.ts:289:42:289:44 | "b" | "b" | -| tst.ts:289:47:289:52 | string | string | -| tst.ts:289:59:289:62 | void | void | -| tst.ts:291:13:291:16 | Func | Func | -| tst.ts:313:12:313:12 | T | T | -| tst.ts:313:20:315:27 | {\\n pro ... void } | { produce: (n: string) => T; consume: (x: T) =>... | -| tst.ts:314:12:314:27 | (n: string) => T | (n: string) => T | -| tst.ts:314:16:314:21 | string | string | -| tst.ts:314:27:314:27 | T | T | -| tst.ts:315:12:315:25 | (x: T) => void | (x: T) => void | -| tst.ts:315:16:315:16 | T | T | -| tst.ts:315:22:315:25 | void | void | -| tst.ts:316:4:316:7 | void | void | -| tst.ts:325:22:325:27 | string | string | -| tst.ts:325:30:325:34 | Error | Error | -| tst.ts:331:6:331:16 | FirstString | FirstString | -| tst.ts:331:18:331:18 | T | T | -| tst.ts:332:3:332:3 | T | T | -| tst.ts:332:13:332:50 | [infer ... nown[]] | [S, ...unknown[]] | -| tst.ts:332:14:332:35 | infer S ... string | S | -| tst.ts:332:20:332:20 | S | S | -| tst.ts:332:30:332:35 | string | string | -| tst.ts:332:38:332:49 | ...unknown[] | unknown | -| tst.ts:332:41:332:47 | unknown | unknown | -| tst.ts:332:41:332:49 | unknown[] | unknown[] | -| tst.ts:333:9:333:9 | S | S | -| tst.ts:334:9:334:13 | never | never | -| tst.ts:336:6:336:6 | F | "a" \| "b" | -| tst.ts:336:10:336:20 | FirstString | FirstString | -| tst.ts:336:10:336:50 | FirstSt ... olean]> | "a" \| "b" | -| tst.ts:336:22:336:49 | ['a' \| ... oolean] | ["a" \| "b", number, boolean] | -| tst.ts:336:23:336:25 | 'a' | "a" | -| tst.ts:336:23:336:31 | 'a' \| 'b' | "a" \| "b" | -| tst.ts:336:29:336:31 | 'b' | "b" | -| tst.ts:336:34:336:39 | number | number | -| tst.ts:336:42:336:48 | boolean | boolean | -| tst.ts:338:10:338:10 | F | "a" \| "b" | -| tst.ts:342:11:342:15 | State | State | -| tst.ts:342:24:342:24 | T | T | -| tst.ts:343:8:343:14 | () => T | () => T | -| tst.ts:343:14:343:14 | T | T | -| tst.ts:344:8:344:25 | (value: T) => void | (value: T) => void | -| tst.ts:344:16:344:16 | T | T | -| tst.ts:344:22:344:25 | void | void | -| tst.ts:347:14:347:18 | State | State | -| tst.ts:347:14:347:26 | State | State | -| tst.ts:347:20:347:25 | number | number | -| tst.ts:381:10:381:16 | SomeNum | 100 | -| tst.ts:381:20:381:24 | "100" | "100" | -| tst.ts:381:20:381:72 | "100" e ... : never | 100 | -| tst.ts:381:37:381:58 | infer U ... number | U | -| tst.ts:381:43:381:43 | U | U | -| tst.ts:381:53:381:58 | number | number | -| tst.ts:381:64:381:64 | U | U | -| tst.ts:381:68:381:72 | never | never | -| tst.ts:383:37:383:37 | T | T | -| tst.ts:383:43:383:43 | T | T | -| tst.ts:383:49:383:49 | T | T | -| tst.ts:383:53:383:53 | T | T | -| tst.ts:391:8:391:13 | Colors | Colors | -| tst.ts:391:17:391:21 | "red" | "red" | -| tst.ts:391:17:391:40 | "red" \| ... "blue" | "red" \| "green" \| "blue" | -| tst.ts:391:25:391:31 | "green" | "green" | -| tst.ts:391:35:391:40 | "blue" | "blue" | -| tst.ts:393:8:393:10 | RGB | RGB | -| tst.ts:393:14:393:55 | [red: n ... number] | [red: number, green: number, blue: number] | -| tst.ts:393:15:393:17 | red | any | -| tst.ts:393:20:393:25 | number | number | -| tst.ts:393:28:393:32 | green | any | -| tst.ts:393:35:393:40 | number | number | -| tst.ts:393:43:393:46 | blue | any | -| tst.ts:393:49:393:54 | number | number | -| tst.ts:399:15:399:20 | Record | Record | -| tst.ts:399:15:399:42 | Record< ... \| RGB> | Record | -| tst.ts:399:22:399:27 | Colors | Colors | -| tst.ts:399:30:399:35 | string | string | -| tst.ts:399:30:399:41 | string \| RGB | string \| RGB | -| tst.ts:399:39:399:41 | RGB | RGB | -| tst.ts:404:13:404:18 | RGBObj | RGBObj | -| tst.ts:405:10:405:15 | number | number | -| tst.ts:408:13:408:18 | HSVObj | HSVObj | -| tst.ts:409:10:409:15 | number | number | -| tst.ts:412:28:412:33 | RGBObj | RGBObj | -| tst.ts:412:28:412:42 | RGBObj \| HSVObj | RGBObj \| HSVObj | -| tst.ts:412:37:412:42 | HSVObj | HSVObj | -| tst.ts:420:20:420:25 | string | string | -| tst.ts:422:23:422:28 | string | string | -| tst.ts:431:27:431:30 | This | This | -| tst.ts:431:33:431:36 | Args | Args | -| tst.ts:431:46:431:48 | any | any | -| tst.ts:431:46:431:50 | any[] | any[] | -| tst.ts:431:53:431:58 | Return | Return | -| tst.ts:432:24:432:27 | This | This | -| tst.ts:432:39:432:42 | Args | Args | -| tst.ts:432:48:432:53 | Return | Return | -| tst.ts:433:18:433:44 | ClassMe ... Context | ClassMethodDecoratorContext | -| tst.ts:433:46:433:49 | This | This | -| tst.ts:433:59:433:62 | This | This | -| tst.ts:433:74:433:77 | Args | Args | -| tst.ts:433:83:433:88 | Return | Return | -| tst.ts:437:42:437:45 | This | This | -| tst.ts:437:57:437:60 | Args | Args | -| tst.ts:437:64:437:69 | Return | Return | -| tst.ts:448:15:448:20 | string | string | -| tst.ts:449:27:449:32 | string | string | -| tst.ts:462:46:462:46 | T | T | -| tst.ts:462:56:462:72 | readonly string[] | readonly string[] | -| tst.ts:462:65:462:70 | string | string | -| tst.ts:462:65:462:72 | string[] | readonly string[] | -| tst.ts:462:81:462:81 | T | T | -| tst.ts:462:85:462:85 | T | T | -| tst.ts:481:10:481:14 | Pair3 | Pair3 | -| tst.ts:481:16:481:16 | T | T | -| tst.ts:481:21:481:33 | [first: T, T] | [first: T, T] | -| tst.ts:481:22:481:26 | first | any | -| tst.ts:481:29:481:29 | T | T | -| tst.ts:481:32:481:32 | T | T | -| tst.ts:483:46:483:50 | Pair3 | Pair3 | -| tst.ts:483:46:483:58 | Pair3 | Pair3 | -| tst.ts:483:52:483:57 | string | string | -| tst.ts:487:30:487:30 | C | C | -| tst.ts:487:40:487:45 | string | string | -| tst.ts:487:56:487:56 | C | C | -| tst.ts:487:56:487:58 | C[] | C[] | -| tst.ts:487:76:487:82 | NoInfer | any | -| tst.ts:487:84:487:84 | C | C | -| tst.ts:506:20:506:25 | Record | Record | -| tst.ts:506:20:506:42 | Record< ... nknown> | Record | -| tst.ts:506:27:506:32 | string | string | -| tst.ts:506:35:506:41 | unknown | unknown | -| tst.ts:506:50:506:55 | string | string | -| tst.ts:514:20:514:25 | symbol | symbol | -| tst.ts:519:21:519:21 | A | A | -| tst.ts:519:21:519:31 | A[typeof a] | () => number | -| tst.ts:519:23:519:30 | typeof a | symbol | -| tst.ts:519:30:519:30 | a | symbol | -| tstModuleCJS.cts:1:33:1:35 | 'a' | "a" | -| tstModuleCJS.cts:1:33:1:41 | 'a' \| 'b' | "a" \| "b" | -| tstModuleCJS.cts:1:39:1:41 | 'b' | "b" | -| tstModuleES.mts:1:40:1:42 | 'a' | "a" | -| tstModuleES.mts:1:40:1:48 | 'a' \| 'b' | "a" \| "b" | -| tstModuleES.mts:1:46:1:48 | 'b' | "b" | -| tstSuffixA.ts:1:33:1:47 | 'tstSuffixA.ts' | "tstSuffixA.ts" | -| tstSuffixB.ios.ts:1:33:1:51 | 'tstSuffixB.ios.ts' | "tstSuffixB.ios.ts" | -| tstSuffixB.ts:1:33:1:47 | 'tstSuffixB.ts' | "tstSuffixB.ts" | -| type_alias.ts:1:6:1:6 | B | boolean | -| type_alias.ts:1:10:1:16 | boolean | boolean | -| type_alias.ts:3:8:3:8 | B | boolean | -| type_alias.ts:5:6:5:17 | ValueOrArray | ValueOrArray | -| type_alias.ts:5:19:5:19 | T | T | -| type_alias.ts:5:24:5:24 | T | T | -| type_alias.ts:5:24:5:49 | T \| Arr ... ray> | T \| ValueOrArray[] | -| type_alias.ts:5:28:5:32 | Array | T[] | -| type_alias.ts:5:28:5:49 | Array> | ValueOrArray[] | -| type_alias.ts:5:34:5:45 | ValueOrArray | ValueOrArray | -| type_alias.ts:5:34:5:48 | ValueOrArray | ValueOrArray | -| type_alias.ts:5:47:5:47 | T | T | -| type_alias.ts:7:8:7:19 | ValueOrArray | ValueOrArray | -| type_alias.ts:7:8:7:27 | ValueOrArray | ValueOrArray | -| type_alias.ts:7:21:7:26 | number | number | -| type_alias.ts:9:6:9:9 | Json | Json | -| type_alias.ts:10:5:15:12 | \| strin ... Json[] | string \| number \| boolean \| { [property: string... | -| type_alias.ts:10:7:10:12 | string | string | -| type_alias.ts:11:7:11:12 | number | number | -| type_alias.ts:12:7:12:13 | boolean | boolean | -| type_alias.ts:13:7:13:10 | null | null | -| type_alias.ts:14:7:14:34 | { [prop ... Json } | { [property: string]: Json; } | -| type_alias.ts:14:20:14:25 | string | string | -| type_alias.ts:14:29:14:32 | Json | Json | -| type_alias.ts:15:7:15:10 | Json | Json | -| type_alias.ts:15:7:15:12 | Json[] | Json[] | -| type_alias.ts:17:11:17:14 | Json | Json | -| type_alias.ts:19:6:19:16 | VirtualNode | VirtualNode | -| type_alias.ts:20:5:21:56 | \| strin ... Node[]] | string \| [string, { [key: string]: any; }, ...V... | -| type_alias.ts:20:7:20:12 | string | string | -| type_alias.ts:21:7:21:56 | [string ... Node[]] | [string, { [key: string]: any; }, ...VirtualNod... | -| type_alias.ts:21:8:21:13 | string | string | -| type_alias.ts:21:16:21:37 | { [key: ... : any } | { [key: string]: any; } | -| type_alias.ts:21:24:21:29 | string | string | -| type_alias.ts:21:33:21:35 | any | any | -| type_alias.ts:21:40:21:55 | ...VirtualNode[] | VirtualNode | -| type_alias.ts:21:43:21:53 | VirtualNode | VirtualNode | -| type_alias.ts:21:43:21:55 | VirtualNode[] | VirtualNode[] | -| type_alias.ts:23:15:23:25 | VirtualNode | VirtualNode | -| type_definitions.ts:3:11:3:11 | I | I | -| type_definitions.ts:3:13:3:13 | S | S | -| type_definitions.ts:4:6:4:6 | S | S | -| type_definitions.ts:6:8:6:8 | I | I | -| type_definitions.ts:6:8:6:16 | I | I | -| type_definitions.ts:6:10:6:15 | number | number | -| type_definitions.ts:8:9:8:9 | T | T | -| type_definitions.ts:9:6:9:6 | T | T | -| type_definitions.ts:11:8:11:8 | C | C | -| type_definitions.ts:11:8:11:16 | C | C | -| type_definitions.ts:11:10:11:15 | number | number | -| type_definitions.ts:16:12:16:16 | Color | Color | -| type_definitions.ts:19:8:19:24 | EnumWithOneMember | EnumWithOneMember | -| type_definitions.ts:21:6:21:10 | Alias | Alias | -| type_definitions.ts:21:12:21:12 | T | T | -| type_definitions.ts:21:17:21:17 | T | T | -| type_definitions.ts:21:17:21:19 | T[] | T[] | -| type_definitions.ts:22:26:22:30 | Alias | Alias | -| type_definitions.ts:22:26:22:38 | Alias | Alias | -| type_definitions.ts:22:32:22:37 | number | number | -missingToString -referenceDefinition -| A | badTypes.ts:5:1:5:29 | interfa ... is.B {} | -| A | tst.ts:515:10:517:3 | class A ... };\\n } | -| Action | tst.ts:252:3:254:50 | type Ac ... ring }; | -| Alias | type_definitions.ts:21:1:21:20 | type Alias = T[]; | -| Alias | type_definitions.ts:21:1:21:20 | type Alias = T[]; | -| Base | tst.ts:241:3:241:15 | class Base {} | -| Base | tst.ts:241:3:241:15 | class Base {} | -| C | tst.ts:203:3:203:46 | type C ... mber>>; | -| C | type_definition_objects.ts:3:8:3:17 | class C {} | -| C | type_definitions.ts:8:1:10:1 | class C ... x: T\\n} | -| C | type_definitions.ts:8:1:10:1 | class C ... x: T\\n} | -| Color | type_definitions.ts:13:1:15:1 | enum Co ... blue\\n} | -| Color.blue | type_definitions.ts:14:15:14:18 | blue | -| Color.green | type_definitions.ts:14:8:14:12 | green | -| Color.red | type_definitions.ts:14:3:14:5 | red | -| Colors | tst.ts:152:5:156:5 | interfa ... ;\\n } | -| Colors | tst.ts:391:3:391:41 | type Co ... "blue"; | -| Data | tst.ts:171:5:173:5 | interfa ... ;\\n } | -| Derived | tst.ts:243:3:250:3 | class D ... }\\n } | -| E | type_definition_objects.ts:6:8:6:16 | enum E {} | -| EnumWithOneMember | type_definitions.ts:18:26:18:31 | member | -| Error | tst.ts:210:10:213:3 | interfa ... ng;\\n } | -| FirstString | tst.ts:331:1:334:14 | type Fi ... never; | -| Foo | tst.ts:116:3:129:3 | class F ... }\\n } | -| Foo | tst.ts:165:5:167:5 | interfa ... ;\\n } | -| Foo | tst.ts:179:3:192:3 | class F ... \\n } | -| Func | tst.ts:289:3:289:63 | type Fu ... > void; | -| HSVObj | tst.ts:408:3:410:3 | interfa ... er;\\n } | -| HasArea | tst.ts:58:1:60:1 | interfa ... mber;\\n} | -| I | type_definitions.ts:3:1:5:1 | interfa ... x: S;\\n} | -| I | type_definitions.ts:3:1:5:1 | interfa ... x: S;\\n} | -| Json | type_alias.ts:9:1:15:13 | type Js ... Json[]; | -| MyUnion | tst.ts:65:1:65:54 | type My ... true}; | -| MyUnion2 | tst.ts:68:1:68:49 | type My ... true}; | -| NonAbstractDummy | tst.ts:54:1:56:1 | interfa ... mber;\\n} | -| Pair3 | tst.ts:481:5:481:34 | type Pa ... T, T]; | -| Pair3 | tst.ts:481:5:481:34 | type Pa ... T, T]; | -| Person | tst.ts:222:3:234:3 | class P ... }\\n } | -| Person | tst.ts:419:3:425:3 | class P ... }\\n } | -| Person | tst.ts:447:5:458:5 | class P ... }\\n } | -| RGB | tst.ts:393:3:393:56 | type RG ... umber]; | -| RGBObj | tst.ts:404:3:406:3 | interfa ... er;\\n } | -| Shape | tst.ts:140:3:142:47 | type Sh ... mber }; | -| SomeClass | tst.ts:473:5:476:5 | class S ... ;\\n } | -| State | tst.ts:342:1:345:1 | interfa ... void;\\n} | -| State | tst.ts:342:1:345:1 | interfa ... void;\\n} | -| Sub | tst.ts:97:3:101:3 | class S ... }\\n } | -| Success | tst.ts:205:10:208:3 | interfa ... ng;\\n } | -| Super | tst.ts:91:3:95:3 | class S ... }\\n } | -| Super | tst.ts:91:3:95:3 | class S ... }\\n } | -| Thing | tst.ts:78:10:88:3 | class T ... }\\n } | -| ThingI | tst.ts:73:3:76:3 | interfa ... n);\\n } | -| TypeMap | tst.ts:265:3:269:3 | interfa ... an;\\n } | -| UnionRecord | tst.ts:271:3:276:7 | type Un ... }[P]; | -| UnionRecord

| tst.ts:271:3:276:7 | type Un ... }[P]; | -| ValueOrArray | type_alias.ts:5:1:5:50 | type Va ... ay>; | -| ValueOrArray | type_alias.ts:5:1:5:50 | type Va ... ay>; | -| VirtualNode | type_alias.ts:19:1:21:57 | type Vi ... ode[]]; | -tupleTypes -| middle-rest.ts:1:5:1:7 | foo | [boolean, ...string[], number] | 0 | boolean | 2 | string | -| middle-rest.ts:1:5:1:7 | foo | [boolean, ...string[], number] | 1 | string | 2 | string | -| middle-rest.ts:1:5:1:7 | foo | [boolean, ...string[], number] | 2 | number | 2 | string | -| middle-rest.ts:3:1:3:3 | foo | [boolean, ...string[], number] | 0 | boolean | 2 | string | -| middle-rest.ts:3:1:3:3 | foo | [boolean, ...string[], number] | 1 | string | 2 | string | -| middle-rest.ts:3:1:3:3 | foo | [boolean, ...string[], number] | 2 | number | 2 | string | -| middle-rest.ts:3:1:3:26 | foo = [ ... ", 123] | [true, string, number] | 0 | true | 3 | no-rest | -| middle-rest.ts:3:1:3:26 | foo = [ ... ", 123] | [true, string, number] | 1 | string | 3 | no-rest | -| middle-rest.ts:3:1:3:26 | foo = [ ... ", 123] | [true, string, number] | 2 | number | 3 | no-rest | -| middle-rest.ts:3:7:3:26 | [true, "hello", 123] | [boolean, ...string[], number] | 0 | boolean | 2 | string | -| middle-rest.ts:3:7:3:26 | [true, "hello", 123] | [boolean, ...string[], number] | 1 | string | 2 | string | -| middle-rest.ts:3:7:3:26 | [true, "hello", 123] | [boolean, ...string[], number] | 2 | number | 2 | string | -| tst.ts:34:5:34:9 | tuple | [number, string] | 0 | number | 2 | no-rest | -| tst.ts:34:5:34:9 | tuple | [number, string] | 1 | string | 2 | no-rest | -| tst.ts:36:5:36:28 | tupleWi ... Element | [number, string, number?] | 0 | number | 2 | no-rest | -| tst.ts:36:5:36:28 | tupleWi ... Element | [number, string, number?] | 1 | string | 2 | no-rest | -| tst.ts:36:5:36:28 | tupleWi ... Element | [number, string, number?] | 2 | number | 2 | no-rest | -| tst.ts:38:5:38:24 | tupleWithRestElement | [number, ...string[]] | 0 | number | 1 | string | -| tst.ts:38:5:38:24 | tupleWithRestElement | [number, ...string[]] | 1 | string | 1 | string | -| tst.ts:39:5:39:36 | tupleWi ... lements | [number, string?, ...number[]] | 0 | number | 1 | number | -| tst.ts:39:5:39:36 | tupleWi ... lements | [number, string?, ...number[]] | 1 | string | 1 | number | -| tst.ts:39:5:39:36 | tupleWi ... lements | [number, string?, ...number[]] | 2 | number | 1 | number | -| tst.ts:42:5:42:21 | constArrayLiteral | readonly [1, 2] | 0 | 1 | 2 | no-rest | -| tst.ts:42:5:42:21 | constArrayLiteral | readonly [1, 2] | 1 | 2 | 2 | no-rest | -| tst.ts:42:25:42:30 | [1, 2] | readonly [1, 2] | 0 | 1 | 2 | no-rest | -| tst.ts:42:25:42:30 | [1, 2] | readonly [1, 2] | 1 | 2 | 2 | no-rest | -| tst.ts:42:25:42:39 | [1, 2] as const | readonly [1, 2] | 0 | 1 | 2 | no-rest | -| tst.ts:42:25:42:39 | [1, 2] as const | readonly [1, 2] | 1 | 2 | 2 | no-rest | -| tst.ts:385:21:385:73 | chooseR ... bye!"]) | [number, boolean, string] | 0 | number | 3 | no-rest | -| tst.ts:385:21:385:73 | chooseR ... bye!"]) | [number, boolean, string] | 1 | boolean | 3 | no-rest | -| tst.ts:385:21:385:73 | chooseR ... bye!"]) | [number, boolean, string] | 2 | string | 3 | no-rest | -| tst.ts:385:36:385:52 | [42, true, "hi!"] | [number, boolean, string] | 0 | number | 3 | no-rest | -| tst.ts:385:36:385:52 | [42, true, "hi!"] | [number, boolean, string] | 1 | boolean | 3 | no-rest | -| tst.ts:385:36:385:52 | [42, true, "hi!"] | [number, boolean, string] | 2 | string | 3 | no-rest | -| tst.ts:385:55:385:72 | [0, false, "bye!"] | [number, boolean, string] | 0 | number | 3 | no-rest | -| tst.ts:385:55:385:72 | [0, false, "bye!"] | [number, boolean, string] | 1 | boolean | 3 | no-rest | -| tst.ts:385:55:385:72 | [0, false, "bye!"] | [number, boolean, string] | 2 | string | 3 | no-rest | -| tst.ts:396:5:396:7 | red | [red: number, green: number, blue: number] | 0 | number | 3 | no-rest | -| tst.ts:396:5:396:7 | red | [red: number, green: number, blue: number] | 1 | number | 3 | no-rest | -| tst.ts:396:5:396:7 | red | [red: number, green: number, blue: number] | 2 | number | 3 | no-rest | -| tst.ts:402:24:402:34 | palette.red | [red: number, green: number, blue: number] | 0 | number | 3 | no-rest | -| tst.ts:402:24:402:34 | palette.red | [red: number, green: number, blue: number] | 1 | number | 3 | no-rest | -| tst.ts:402:24:402:34 | palette.red | [red: number, green: number, blue: number] | 2 | number | 3 | no-rest | -| tst.ts:402:32:402:34 | red | [red: number, green: number, blue: number] | 0 | number | 3 | no-rest | -| tst.ts:402:32:402:34 | red | [red: number, green: number, blue: number] | 1 | number | 3 | no-rest | -| tst.ts:402:32:402:34 | red | [red: number, green: number, blue: number] | 2 | number | 3 | no-rest | -| tst.ts:465:11:465:13 | foo | readonly ["a", "b", "c"] | 0 | "a" | 3 | no-rest | -| tst.ts:465:11:465:13 | foo | readonly ["a", "b", "c"] | 1 | "b" | 3 | no-rest | -| tst.ts:465:11:465:13 | foo | readonly ["a", "b", "c"] | 2 | "c" | 3 | no-rest | -| tst.ts:465:17:465:50 | myConst ... ,"c"]) | readonly ["a", "b", "c"] | 0 | "a" | 3 | no-rest | -| tst.ts:465:17:465:50 | myConst ... ,"c"]) | readonly ["a", "b", "c"] | 1 | "b" | 3 | no-rest | -| tst.ts:465:17:465:50 | myConst ... ,"c"]) | readonly ["a", "b", "c"] | 2 | "c" | 3 | no-rest | -| tst.ts:465:35:465:49 | ["a", "b" ,"c"] | readonly ["a", "b", "c"] | 0 | "a" | 3 | no-rest | -| tst.ts:465:35:465:49 | ["a", "b" ,"c"] | readonly ["a", "b", "c"] | 1 | "b" | 3 | no-rest | -| tst.ts:465:35:465:49 | ["a", "b" ,"c"] | readonly ["a", "b", "c"] | 2 | "c" | 3 | no-rest | -| tst.ts:467:15:467:17 | foo | readonly ["a", "b", "c"] | 0 | "a" | 3 | no-rest | -| tst.ts:467:15:467:17 | foo | readonly ["a", "b", "c"] | 1 | "b" | 3 | no-rest | -| tst.ts:467:15:467:17 | foo | readonly ["a", "b", "c"] | 2 | "c" | 3 | no-rest | -| tst.ts:483:17:483:58 | ["hello ... string> | [first: string, string] | 0 | string | 2 | no-rest | -| tst.ts:483:17:483:58 | ["hello ... string> | [first: string, string] | 1 | string | 2 | no-rest | -unknownType -| tst.ts:40:5:40:15 | unknownType | unknown | -| tst.ts:47:8:47:8 | e | unknown | -| tst.ts:48:14:48:14 | e | unknown | -| tst.ts:133:16:133:18 | arg | unknown | -| tst.ts:134:32:134:34 | arg | unknown | -| tst.ts:228:12:228:16 | other | unknown | -| tst.ts:229:16:229:20 | other | unknown | -| tst.ts:230:20:230:24 | other | unknown | -| tst.ts:507:16:507:23 | obj[key] | unknown | -abstractSignature -| (): HasArea | -| new (): HasArea | -unionIndex -| 1 | 0 | 1 \| 2 | -| 2 | 1 | 1 \| 2 | -| 42 | 1 | "hello" \| 42 | -| "NumberContents" | 0 | "NumberContents" \| "StringContents" | -| "StringContents" | 1 | "NumberContents" \| "StringContents" | -| "a" | 0 | "a" \| "b" | -| "a" | 0 | "a" \| "b" \| "c" | -| "a" | 1 | number \| "a" | -| "a" | 3 | number \| boolean \| "a" \| "b" | -| "b" | 1 | "a" \| "b" | -| "b" | 1 | "a" \| "b" \| "c" | -| "b" | 4 | number \| boolean \| "a" \| "b" | -| "bigint" | 2 | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| "blue" | 2 | "red" \| "green" \| "blue" | -| "boolean" | 2 | keyof TypeMap | -| "boolean" | 3 | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| "c" | 2 | "a" \| "b" \| "c" | -| "circle" | 0 | "circle" \| "square" | -| "even" | 0 | "even" \| "odd" | -| "function" | 7 | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| "green" | 1 | "red" \| "green" \| "blue" | -| "green" | 1 | "red" \| "green" \| "yellow" | -| "hello" | 0 | "hello" \| 42 | -| "number" | 1 | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| "number" | 1 | keyof TypeMap | -| "object" | 6 | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| "odd" | 1 | "even" \| "odd" | -| "red" | 0 | "red" \| "green" \| "blue" | -| "red" | 0 | "red" \| "green" \| "yellow" | -| "square" | 1 | "circle" \| "square" | -| "string" | 0 | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| "string" | 0 | keyof TypeMap | -| "symbol" | 4 | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| "undefined" | 5 | "string" \| "number" \| "bigint" \| "boolean" \| "s... | -| "yellow" | 2 | "red" \| "green" \| "yellow" | -| () => number | 0 | (() => number) \| (ClassMethodDecoratorContext number | 1 | void \| (() => number) | -| ClassMethodDecoratorContext numbe... | 1 | (() => number) \| (ClassMethodDecoratorContext | 2 | boolean \| Promise | -| PromiseLike | 1 | TResult1 \| PromiseLike | -| PromiseLike | 1 | TResult2 \| PromiseLike | -| RGB | 1 | string \| RGB | -| RGBObj | 0 | RGBObj \| HSVObj | -| Success | 0 | Success \| Error | -| T | 0 | T \| ValueOrArray[] | -| TResult1 | 0 | TResult1 \| PromiseLike | -| TResult1 | 0 | TResult1 \| TResult2 | -| TResult2 | 0 | TResult2 \| PromiseLike | -| TResult2 | 1 | TResult1 \| TResult2 | -| ValueOrArray[] | 1 | T \| ValueOrArray[] | -| ValueOrArray[] | 1 | number \| ValueOrArray[] | -| ["a", number] | 0 | ["a", number] \| ["b", string] | -| ["b", string] | 1 | ["a", number] \| ["b", string] | -| [string, { [key: string]: any; }, ...VirtualNod... | 1 | VirtualNode \| { [key: string]: any; } | -| [string, { [key: string]: any; }, ...VirtualNod... | 1 | string \| [string, { [key: string]: any; }, ...V... | -| false | 0 | boolean | -| false | 0 | boolean \| Promise | -| false | 1 | number \| boolean | -| false | 1 | number \| boolean \| "a" \| "b" | -| false | 2 | string \| number \| boolean | -| false | 2 | string \| number \| boolean \| { [property: string... | -| number | 0 | number \| "a" | -| number | 0 | number \| ValueOrArray[] | -| number | 0 | number \| boolean | -| number | 0 | number \| boolean \| "a" \| "b" | -| number | 1 | string \| number | -| number | 1 | string \| number \| boolean | -| number | 1 | string \| number \| boolean \| { [property: string... | -| number | 1 | string \| number \| symbol | -| number | 1 | string \| number \| true | -| string | 0 | VirtualNode \| { [key: string]: any; } | -| string | 0 | string \| Error | -| string | 0 | string \| RGB | -| string | 0 | string \| [string, { [key: string]: any; }, ...V... | -| string | 0 | string \| number | -| string | 0 | string \| number \| boolean | -| string | 0 | string \| number \| boolean \| { [property: string... | -| string | 0 | string \| number \| symbol | -| string | 0 | string \| number \| true | -| string | 0 | string \| symbol | -| string | 0 | string \| { [key: string]: any; } | -| symbol | 1 | string \| symbol | -| symbol | 2 | string \| number \| symbol | -| true | 1 | boolean | -| true | 1 | boolean \| Promise | -| true | 2 | number \| boolean | -| true | 2 | number \| boolean \| "a" \| "b" | -| true | 2 | string \| number \| true | -| true | 3 | string \| number \| boolean | -| true | 3 | string \| number \| boolean \| { [property: string... | -| void | 0 | void \| (() => number) | -| { [key: string]: any; } | 1 | string \| { [key: string]: any; } | -| { [key: string]: any; } | 2 | VirtualNode \| { [key: string]: any; } | -| { [property: string]: Json; } | 4 | string \| number \| boolean \| { [property: string... | -| { kind: "NumberContents"; payload: number; } | 0 | { kind: "NumberContents"; payload: number; } \| ... | -| { kind: "StringContents"; payload: string; } | 1 | { kind: "NumberContents"; payload: number; } \| ... | -| { kind: "circle"; radius: number; } | 0 | { kind: "circle"; radius: number; } \| { kind: "... | -| { kind: "square"; sideLength: number; } | 1 | { kind: "circle"; radius: number; } \| { kind: "... | -| { myUnion: true; } | 0 | MyUnion \| { yetAnotherType: true; } | -| { myUnion: true; } | 0 | { myUnion: true; } \| { stillMyUnion: true; } | -| { stillMyUnion: true; } | 1 | MyUnion \| { yetAnotherType: true; } | -| { stillMyUnion: true; } | 1 | { myUnion: true; } \| { stillMyUnion: true; } | -| { yetAnotherType: true; } | 2 | MyUnion \| { yetAnotherType: true; } | -getAStaticInitializerBlock -| tst.ts:179:3:192:3 | class F ... \\n } | tst.ts:185:5:187:5 | static ... ;\\n } | -| tst.ts:179:3:192:3 | class F ... \\n } | tst.ts:188:5:190:5 | static ... ;\\n } | diff --git a/javascript/ql/test/library-tests/TypeScript/Types/tests.ql b/javascript/ql/test/library-tests/TypeScript/Types/tests.ql deleted file mode 100644 index dad3934113e3..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/tests.ql +++ /dev/null @@ -1,45 +0,0 @@ -import javascript - -// Ensure `true | false` and `false | true` are not distinct boolean types. -query predicate booleans(BooleanType t) { any() } - -query predicate getExprType(Expr expr, Type type) { type = expr.getType() } - -query predicate getTypeDefinitionType(TypeDefinition def, Type type) { type = def.getType() } - -query predicate getTypeExprType(TypeExpr e, Type type) { e.getType() = type } - -query predicate missingToString(Type typ, string msg) { - not exists(typ.toString()) and - msg = "Missing toString for " + typ.getAQlClass() -} - -query predicate referenceDefinition(TypeReference ref, TypeDefinition def) { - def = ref.getADefinition() -} - -string getRest(TupleType tuple) { - if tuple.hasRestElement() - then result = tuple.getRestElementType().toString() - else result = "no-rest" -} - -query predicate tupleTypes(Expr e, TupleType tuple, int n, Type element, int minLength, string rest) { - e.getType() = tuple and - element = tuple.getElementType(n) and - minLength = tuple.getMinimumLength() and - rest = getRest(tuple) -} - -query predicate unknownType(Expr e, Type type) { - type = e.getType() and - e.getType() instanceof UnknownType -} - -query CallSignatureType abstractSignature() { result.isAbstract() } - -query UnionType unionIndex(Type element, int i) { result.getElementType(i) = element } - -query BlockStmt getAStaticInitializerBlock(ClassDefinition cls) { - result = cls.getAStaticInitializerBlock() -} diff --git a/javascript/ql/test/library-tests/TypeScript/Types/tsconfig.json b/javascript/ql/test/library-tests/TypeScript/Types/tsconfig.json deleted file mode 100644 index 2235cec7f7d4..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/tsconfig.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "compilerOptions": { - "module": "esnext", - "target": "esnext", - "lib": ["dom", "esnext"], - "resolveJsonModule": true, - "moduleSuffixes": [".ios", ""] - } -} diff --git a/javascript/ql/test/library-tests/TypeScript/Types/tst.ts b/javascript/ql/test/library-tests/TypeScript/Types/tst.ts deleted file mode 100644 index 87f876be9d0f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/tst.ts +++ /dev/null @@ -1,520 +0,0 @@ -import * as dummy from "./dummy"; - -var numVar: number; - -var num1 = numVar; -var num2 = 5; -var num3 = num1 + num2; - -var strVar: string; -var hello = "hello"; -var world = "world"; -var msg = hello + " " + world; - -function concat(x: string, y: string): string { return x + y; } - -function add(x: number, y: number): number { return x + y; } - -function untyped(x, y) { return x + y; } - -function partialTyped(x, y: string) { return x + y; } - -for (let numFromLoop of [1, 2]) {} - -let array: number[]; - -let voidType: () => void; -let undefinedType: undefined; -let nullType: null = null; -let neverType: () => never; -let symbolType: symbol; -const uniqueSymbolType: unique symbol = null; -let objectType: object; -let intersection: string & {x: string}; -let tuple: [number, string]; - -let tupleWithOptionalElement: [number, string, number?]; -let emptyTuple: []; -let tupleWithRestElement: [number, ...string[]]; -let tupleWithOptionalAndRestElements: [number, string?, ...number[]]; -let unknownType: unknown; - -let constArrayLiteral = [1, 2] as const; -let constObjectLiteral = { foo: "foo" } as const; - - -try { } -catch (e: unknown) { - if (typeof e === "string") { - let b : string = e; - } -} - - -interface NonAbstractDummy { - getArea(): number; -} - -interface HasArea { - getArea(): number; -} - -// abstract construct signature! -let Ctor: abstract new () => HasArea = Shape; - -type MyUnion = {myUnion: true} | {stillMyUnion: true}; -let union1: MyUnion = {myUnion: true}; - -type MyUnion2 = MyUnion | {yetAnotherType: true}; -let union2: MyUnion2 = {yetAnotherType: true}; - -module TS43 { - // TypeScript 4.3 setter/getter types - interface ThingI { - get size(): number - set size(value: number | string | boolean); - } - - export class Thing implements ThingI { - #size = 0; - - get size(): number { - return this.#size; - } - - set size(value: string | number | boolean) { - this.#size = Number(value); - } - } - - // overrides - class Super { - random(): number { - return 4; - } - } - - class Sub extends Super { - override random(): number { - return super.random() * 10; - } - } - - // inference of template strings. - function bar(s: string): `hello ${string}` { - // Previously an error, now works! - return `hello ${s}`; - } - - declare let s1: `${number}-${number}-${number}`; - declare let s2: `1-2-3`; - declare let s3: `${number}-2-3`; - s1 = s2; - s1 = s3; - - // private methods - class Foo { - #someMethod(): number { - return 42; - } - - get #someValue(): number { - return 100; - } - - publicMethod() { - this.#someMethod(); - return this.#someValue; - } - } -} - -module TS44 { - function foo(arg: unknown) { - const argIsString = typeof arg === "string"; - if (argIsString) { - const upper = arg.toUpperCase(); - } - } - - type Shape = - | { kind: "circle", radius: number } - | { kind: "square", sideLength: number }; - - function side(shape: Shape): number { - const { kind } = shape; - - if (kind === "circle") { return shape.radius;} - else { return shape.sideLength; } - } - - function symbolIndex() { - interface Colors { - [sym: symbol]: number; - [key: string]: string; - [num: number]: boolean; - } - - let colors: Colors = {}; - const red = colors[Symbol("red")]; - const green = colors["green"]; - const blue = colors[2]; - } - - function stringPatternIndex() { - interface Foo { - [key: `foo-${number}`]: number; - } - var bla : Foo = {}; - const bar = bla[`foo-1`]; - - interface Data { - [optName: string | symbol]: boolean; - } - - const data: Data = {}; - const baz = data["foo"]; - } - - class Foo { - static #count = 0; - - get count() { - return Foo.#count; - } - static { - Foo.#count += 3; - } - static { - var count = Foo.#count; - } - - } -} - -module TS45 { - // A = string - type A = Awaited>; - - // B = number - type B = Awaited>>; - - // C = boolean | number - type C = Awaited>; - - export interface Success { - type: `${string}Success`; - body: string; - } - - export interface Error { - type: `${string}Error`; - message: string; - } - - export function handler(r: Success | Error) { - if (r.type === "HttpSuccess") { - // 'r' has type 'Success' - let token = r.body; - } - } - - class Person { - #name: string; - constructor(name: string) { - this.#name = name; - } - - equals(other: unknown) { - return other && - typeof other === "object" && - #name in other && // <- this is new! - this.#name === other.#name; // <- other has type Person here. - } - } -} - -import * as Foo3 from "./something.json" with { type: "json" }; -var foo = Foo3.foo; - -module TS46 { - class Base {} - - class Derived extends Base { - myProp = true; - - constructor() { - console.log("Doing something before super()"); - super(); - } - } - - type Action = - | { kind: "NumberContents"; payload: number } - | { kind: "StringContents"; payload: string }; - - function processAction(action: Action) { - const { kind, payload } = action; - if (kind === "NumberContents") { - console.log(payload.toFixed()); // <- number - } else if (kind === "StringContents") { - console.log(payload.toLowerCase()); // <- string - } - } - - interface TypeMap { - number: number; - string: string; - boolean: boolean; - } - - type UnionRecord

= { - [K in P]: { - kind: K; - f: (p: TypeMap[K]) => void; - }; - }[P]; - - function processRecord(record: UnionRecord) { - record.f(record.v); - } - - processRecord({ - kind: "string", - f: (val) => { - console.log(val.toUpperCase()); // <- string - }, - }); - - type Func = (...args: ["a", number] | ["b", string]) => void; - - const f1: Func = (kind, payload) => { - if (kind === "a") { - payload.toFixed(); // <- number - } - }; -} - -const key = Symbol(); - -const numberOrString = Math.random() < 0.5 ? 42 : "hello"; - -let obj = { - [key]: numberOrString, -}; - -if (typeof obj[key] === "string") { - let str = obj[key]; // <- string - str.toUpperCase(); -} - -////////// - -function f(arg: { - produce: (n: string) => T, - consume: (x: T) => void } -): void {}; - -f({ - produce: n => n, // <- (n: string) => string - consume: x => x.toLowerCase() -}); - -/////////// - -const ErrorMap = Map; - -const errorMap = new ErrorMap(); // <- Map - -//////////// - -type FirstString = - T extends [infer S extends string, ...unknown[]] - ? S - : never; - -type F = FirstString<['a' | 'b', number, boolean]>; - -const a: F = 'a'; // <- 'a' | 'b' - -//////////// - -interface State { - get: () => T; - set: (value: T) => void; -} - -const state: State = { - get: () => 42, - set: (value) => { } -} - -const fortyTwo = state.get(); // <- number - -///////////////// - -import tstModuleES from './tstModuleES.mjs'; - -console.log(tstModuleES()); - -import { tstModuleCJS } from './tstModuleCJS.cjs'; - -console.log(tstModuleCJS()); - -///////////////// - -// test file resolution order (see tsconfig: moduleSuffixes setting) - -import * as A from './tstSuffixA'; - -console.log(A.resolvedFile()); // <- 'tstSuffixA.ts' - -import * as B from './tstSuffixB'; - -console.log(B.resolvedFile()); // <- 'tstSuffixB.ios.ts' - - -///////////////// - -module TS48 { - // SomeNum used to be 'number'; now it's '100'. - type SomeNum = "100" extends `${infer U extends number}` ? U : never; - - declare function chooseRandomly(x: T, y: T): T; - - let [a, b, c] = chooseRandomly([42, true, "hi!"], [0, false, "bye!"]); -} - -///////////////// - -module TS49 { - type Colors = "red" | "green" | "blue"; - - type RGB = [red: number, green: number, blue: number]; - - const palette = { - red: [255, 0, 0], - green: "#00ff00", - bleu: [0, 0, 255], - } satisfies Record; - - // Both of these methods are still accessible! - const redComponent = palette.red.at(0); - - interface RGBObj { - red: number; - } - - interface HSVObj { - hue: number; - } - - function setColor(color: RGBObj | HSVObj) { - if ("hue" in color) { - let h = color; // <- HSVObj - } - } - - // auto-accessors - class Person { - accessor name: string; // behaves as a normal field for our purposes - - constructor(name: string) { - this.name = name; - } - } -} - -///////////////// - -module TS50 { - function loggedMethod( - target: (this: This, ...args: Args) => Return, - context: ClassMethodDecoratorContext Return> - ) { - const methodName = String(context.name); - - function replacementMethod(this: This, ...args: Args): Return { - console.log(`LOG: Entering method '${methodName}'.`) - const result = target.call(this, ...args); - console.log(`LOG: Exiting method '${methodName}'.`) - return result; - } - - return replacementMethod; - } - - class Person { - name: string; - constructor(name: string) { - this.name = name; - } - - @loggedMethod("") - greet() { - console.log(`Hello, my name is ${this.name}.`); - return 2; - } - } - - const p = new Person("John").greet(); // <- number, part of well-typed decorators in TS 5.0. - - declare function myConstIdFunction(args: T): T; - - // foo is readonly ["a", "b", "c"] - const foo = myConstIdFunction(["a", "b" ,"c"]); - - const b = foo[1]; // <- "b" -} - -///////////////// - -module TS52 { - class SomeClass { - @((_target, _context) => {}) - foo = 123; - } - - console.log(SomeClass[Symbol.metadata]); // <- has type DecoratorMetadataObject - - // named and anonymous tuple elements. - type Pair3 = [first: T, T]; - - console.log(["hello", "world"] satisfies Pair3); -} - -module TS54 { - function createStreetLight(colors: C[], defaultColor?: NoInfer) { - return colors[0]; - } - - createStreetLight(["red", "yellow", "green"], "yellow"); - - const myObj = Object.groupBy([0, 1, 2, 3, 4, 5], (num, index) => { - return num % 2 === 0 ? "even": "odd"; - }); -} - -module TS55 { - const strings = (["foo", 123]) - .filter(s => typeof s === "string"); - - for (const str of strings) { - str.toLowerCase(); // <- string in 5.5, string | number in 5.4 - } - - function f1(obj: Record, key: string) { - if (typeof obj[key] === "string") { - var str = obj[key].toUpperCase(); // Now okay, previously was error - } - } -} - -namespace TS57{ - declare const a: symbol; - export class A { - [a]() { return 1 }; - } - - declare const e1: A[typeof a]; // Now okay, previously was compilation error TS2538: Type 'symbol' cannot be used as an index type. -} diff --git a/javascript/ql/test/library-tests/TypeScript/Types/tstModuleCJS.cts b/javascript/ql/test/library-tests/TypeScript/Types/tstModuleCJS.cts deleted file mode 100644 index c764c1e1243f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/tstModuleCJS.cts +++ /dev/null @@ -1,3 +0,0 @@ -export function tstModuleCJS(): 'a' | 'b' { - return Math.random() > 0.5 ? 'a' : 'b'; -} diff --git a/javascript/ql/test/library-tests/TypeScript/Types/tstModuleES.mts b/javascript/ql/test/library-tests/TypeScript/Types/tstModuleES.mts deleted file mode 100644 index cf735d1bb493..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/tstModuleES.mts +++ /dev/null @@ -1,3 +0,0 @@ -export default function tstModuleES(): 'a' | 'b' { - return Math.random() > 0.5 ? 'a' : 'b'; -} diff --git a/javascript/ql/test/library-tests/TypeScript/Types/tstSuffixA.ts b/javascript/ql/test/library-tests/TypeScript/Types/tstSuffixA.ts deleted file mode 100644 index ffe0b8114924..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/tstSuffixA.ts +++ /dev/null @@ -1,3 +0,0 @@ -export function resolvedFile(): 'tstSuffixA.ts' { - return 'tstSuffixA.ts'; -} diff --git a/javascript/ql/test/library-tests/TypeScript/Types/tstSuffixB.ios.ts b/javascript/ql/test/library-tests/TypeScript/Types/tstSuffixB.ios.ts deleted file mode 100644 index 04463fc7699f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/tstSuffixB.ios.ts +++ /dev/null @@ -1,3 +0,0 @@ -export function resolvedFile(): 'tstSuffixB.ios.ts' { - return 'tstSuffixB.ios.ts'; -} diff --git a/javascript/ql/test/library-tests/TypeScript/Types/tstSuffixB.ts b/javascript/ql/test/library-tests/TypeScript/Types/tstSuffixB.ts deleted file mode 100644 index cdb26f8f6146..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/tstSuffixB.ts +++ /dev/null @@ -1,3 +0,0 @@ -export function resolvedFile(): 'tstSuffixB.ts' { - return 'tstSuffixB.ts'; -} diff --git a/javascript/ql/test/library-tests/TypeScript/Types/type_alias.ts b/javascript/ql/test/library-tests/TypeScript/Types/type_alias.ts deleted file mode 100644 index d13eb159754f..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/type_alias.ts +++ /dev/null @@ -1,27 +0,0 @@ -type B = boolean; - -var b: B; - -type ValueOrArray = T | Array>; - -var c: ValueOrArray; - -type Json = - | string - | number - | boolean - | null - | { [property: string]: Json } - | Json[]; - -var json: Json; - -type VirtualNode = - | string - | [string, { [key: string]: any }, ...VirtualNode[]]; - -const myNode: VirtualNode = - ["div", { id: "parent" }, - ["div", { id: "first-child" }, "I'm the first child"], - ["div", { id: "second-child" }, "I'm the second child"] - ]; diff --git a/javascript/ql/test/library-tests/TypeScript/Types/type_definition_objects.ts b/javascript/ql/test/library-tests/TypeScript/Types/type_definition_objects.ts deleted file mode 100644 index b365d7ecbbed..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/type_definition_objects.ts +++ /dev/null @@ -1,10 +0,0 @@ -import * as dummy from "./dummy"; - -export class C {} -let classObj = C; - -export enum E {} -let enumObj = E; - -export namespace N {;} -let namespaceObj = N; diff --git a/javascript/ql/test/library-tests/TypeScript/Types/type_definitions.ts b/javascript/ql/test/library-tests/TypeScript/Types/type_definitions.ts deleted file mode 100644 index f9e32ded1258..000000000000 --- a/javascript/ql/test/library-tests/TypeScript/Types/type_definitions.ts +++ /dev/null @@ -1,22 +0,0 @@ -import * as dummy from "./dummy"; - -interface I { - x: S; -} -let i: I - -class C { - x: T -} -let c: C; - -enum Color { - red, green, blue -} -let color: Color; - -enum EnumWithOneMember { member } -let e: EnumWithOneMember; - -type Alias = T[]; -let aliasForNumberArray: Alias; diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/calls.ts b/javascript/ql/test/library-tests/UnderlyingTypes/calls.ts new file mode 100644 index 000000000000..68509e4a1c63 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/calls.ts @@ -0,0 +1,32 @@ +import * as express from 'express'; + +function getRequest(): express.Request { } + +function t1() { + getRequest(); // $ hasUnderlyingType='express'.Request +} + +declare function getRequestAmbient(): express.Request; + +function t2() { + getRequestAmbient(); // $ hasUnderlyingType='express'.Request +} + +class C { + method(): express.Request { } +} + +function t3(c: C) { + c.method(); // $ hasUnderlyingType='express'.Request + new C().method(); // $ hasUnderlyingType='express'.Request +} + +function callback(fn: (req: express.Request) => void) { // $ SPURIOUS: hasUnderlyingType='express'.Request // req seems to be a SourceNode +} + +function t4() { + callback(function ( + req // $ hasUnderlyingType='express'.Request + ) { } + ); +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/closure.es.js b/javascript/ql/test/library-tests/UnderlyingTypes/closure.es.js new file mode 100644 index 000000000000..cb140ec63c97 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/closure.es.js @@ -0,0 +1,5 @@ +goog.declareModuleId("closure.es") + +const Bar = goog.require('closure.reexported.Bar'); + +export { Bar } diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/closure.lib.js b/javascript/ql/test/library-tests/UnderlyingTypes/closure.lib.js new file mode 100644 index 000000000000..ffd67593202c --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/closure.lib.js @@ -0,0 +1,3 @@ +goog.module("closure.lib") + +exports.Foo = goog.require('closure.reexported.Foo'); diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/closure.use.js b/javascript/ql/test/library-tests/UnderlyingTypes/closure.use.js new file mode 100644 index 000000000000..22fc397cf3d0 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/closure.use.js @@ -0,0 +1,16 @@ +goog.module("closure.use") + +const lib = goog.require("closure.lib"); +const es = goog.require("closure.es"); + +/** + * @param {lib.Foo} x + */ +function t1(x) { // $ hasUnderlyingType=closure.reexported.Foo hasUnderlyingType=closure.lib.Foo +} + +/** + * @param {es.Bar} x + */ +function t2(x) { // $ hasUnderlyingType=closure.reexported.Bar hasUnderlyingType=closure.es.Bar +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/contextualTypes.ts b/javascript/ql/test/library-tests/UnderlyingTypes/contextualTypes.ts new file mode 100644 index 000000000000..cc461c5c7dda --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/contextualTypes.ts @@ -0,0 +1,45 @@ +import * as express from 'express'; + +interface Options { + handle(req: express.Request): void; // $ hasUnderlyingType='express'.Request +} + +declare function doSomething(options: Options); + +function t1() { + doSomething({ + handle(req) { // $ hasUnderlyingType='express'.Request + } + }); +} + +function t2(callback: ((opts: Options) => void) | undefined) { + callback({ + handle(req) { } // $ hasUnderlyingType='express'.Request + }) + callback!({ + handle(req) { } // $ hasUnderlyingType='express'.Request + }) +} + +function t3(): Options { + return { + handle(req) { } // $ hasUnderlyingType='express'.Request + } +} + +function t4(): Options[] { + return [ + { + handle(req) { } // $ hasUnderlyingType='express'.Request + } + ] +} + +async function t5(): Promise { + return { + handle(req) { // $ hasUnderlyingType='express'.Request + + } + } +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/dynamicImportLib.ts b/javascript/ql/test/library-tests/UnderlyingTypes/dynamicImportLib.ts new file mode 100644 index 000000000000..93324a153909 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/dynamicImportLib.ts @@ -0,0 +1,4 @@ +import * as express from 'express'; + +export async function getRequest(): express.Request { +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/dynamicImportUse.ts b/javascript/ql/test/library-tests/UnderlyingTypes/dynamicImportUse.ts new file mode 100644 index 000000000000..cca2b265f285 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/dynamicImportUse.ts @@ -0,0 +1,4 @@ +async function t1() { + const e = await import('./dynamicImportLib'); + e.getRequest(); // $ hasUnderlyingType='express'.Request +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressBulkExport.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressBulkExport.ts new file mode 100644 index 000000000000..47ef09acc6e5 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressBulkExport.ts @@ -0,0 +1 @@ +export * from 'express'; diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressBulkExport.use.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressBulkExport.use.ts new file mode 100644 index 000000000000..bb94da47faf9 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressBulkExport.use.ts @@ -0,0 +1,7 @@ +import { Request, Response } from './expressBulkExport'; + +function t1(req: Request) { // $ hasUnderlyingType='express'.Request +} + +function t2(res: Response) { // $ hasUnderlyingType='express'.Response +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssign.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssign.ts new file mode 100644 index 000000000000..8aa013bcde09 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssign.ts @@ -0,0 +1,2 @@ +import E = require('express'); +export = E; diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssign.use.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssign.use.ts new file mode 100644 index 000000000000..da65575a443a --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssign.use.ts @@ -0,0 +1,4 @@ +import { Request } from "./expressExportAssign"; + +function t1(req: Request) { // $ hasUnderlyingType='express'.Request +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssignWrapper.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssignWrapper.ts new file mode 100644 index 000000000000..23c22e445914 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssignWrapper.ts @@ -0,0 +1,5 @@ +import Express = require('express'); +namespace Wrapper { + export import E = Express; +} +export = Wrapper; diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssignWrapper.use.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssignWrapper.use.ts new file mode 100644 index 000000000000..7bcf4b419e95 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressExportAssignWrapper.use.ts @@ -0,0 +1,4 @@ +import { E } from "./expressExportAssignWrapper"; + +function t1(req: E.Request) { // $ hasUnderlyingType='express'.Request +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressSelectiveExport.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressSelectiveExport.ts new file mode 100644 index 000000000000..c8aaf3bb9956 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressSelectiveExport.ts @@ -0,0 +1,2 @@ +export { Request } from 'express'; +export { Response as R } from 'express'; diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressSelectiveExport.use.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressSelectiveExport.use.ts new file mode 100644 index 000000000000..41ce42e3b1fa --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressSelectiveExport.use.ts @@ -0,0 +1,10 @@ +import { Request, Response, R } from './expressSelectiveExport'; + +function t1(req: Request) { // $ hasUnderlyingType='express'.Request +} + +function t2(res: Response) { // none, not exported +} + +function t3(res: R) { // $ hasUnderlyingType='express'.Response +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressWrapperExport.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressWrapperExport.ts new file mode 100644 index 000000000000..6fae12f06847 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressWrapperExport.ts @@ -0,0 +1 @@ +export * as wrapper from 'express'; diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/expressWrapperExport.use.ts b/javascript/ql/test/library-tests/UnderlyingTypes/expressWrapperExport.use.ts new file mode 100644 index 000000000000..62f7e519ff0e --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/expressWrapperExport.use.ts @@ -0,0 +1,29 @@ +import { Request, Response, wrapper } from './expressWrapperExport'; +import * as w from './expressWrapperExport'; + +function t1(req: Request) { // none +} + +function t2(res: Response) { // none +} + +function t3(req: wrapper.Request) { // $ hasUnderlyingType='express'.Request +} + +function t4(res: wrapper.Response) { // $ hasUnderlyingType='express'.Response +} + +function t5(req: w.wrapper.Request) { // $ hasUnderlyingType='express'.Request +} + +function t6(res: w.wrapper.Response) { // $ hasUnderlyingType='express'.Response +} + +function t7(req: w.Request) { // none +} + +function t8(res: w.Response) { // none +} + +function t9(e: typeof w.wrapper) { // $ hasUnderlyingType='express' +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/generics.ts b/javascript/ql/test/library-tests/UnderlyingTypes/generics.ts new file mode 100644 index 000000000000..26e4499f4da2 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/generics.ts @@ -0,0 +1,46 @@ +import * as express from 'express'; + +type Box1 = { + value: T; + other: string; +}; +function t1(b: Box1) { + b.value; // $ MISSING: hasUnderlyingType='express'.Request + b.other; +} + +interface Box2 { + value: T; + other: string; +} +function t2(b: Box2) { + b.value; // $ MISSING: hasUnderlyingType='express'.Request + b.other; +} + +class Box3 { + value: T; + other: string; +} +function t3(b: Box3) { + b.value; // $ MISSING: hasUnderlyingType='express'.Request + b.other; +} + +abstract class Box4 { + abstract getValue(): T; + abstract getOther(): string; +} +function t4(b: Box4) { + b.getValue(); // $ MISSING: hasUnderlyingType='express'.Request + b.getOther(); +} + +type Box5 = { + value: T & { blah: string }; + other: string; +}; +function t5(b: Box5) { + b.value; // $ MISSING: hasUnderlyingType='express'.Request + b.other; +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/globals.ts b/javascript/ql/test/library-tests/UnderlyingTypes/globals.ts new file mode 100644 index 000000000000..8fc6546c70f3 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/globals.ts @@ -0,0 +1,10 @@ +function t1(el: HTMLElement) { } // $ hasUnderlyingType=HTMLElement + +/** + * @param {HTMLInputElement} el + */ +function t2(el) { // $ hasUnderlyingType=HTMLInputElement +} + +function t3(req: Express.Request) { // $ hasUnderlyingType=Express.Request +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/jsdoc.js b/javascript/ql/test/library-tests/UnderlyingTypes/jsdoc.js new file mode 100644 index 000000000000..662faeb52c9a --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/jsdoc.js @@ -0,0 +1,14 @@ +import * as e from 'express'; +import { Response } from 'express'; + +/** + * @param {e.Request} req + */ +function t1(req) { // $ hasUnderlyingType='express'.Request +} + +/** + * @param {Response} res + */ +function t2(res) { // $ hasUnderlyingType='express'.Response +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/namedImport.ts b/javascript/ql/test/library-tests/UnderlyingTypes/namedImport.ts new file mode 100644 index 000000000000..56b1d43d399d --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/namedImport.ts @@ -0,0 +1,4 @@ +import { Request } from 'express'; + +function t1(req: Request) { // $ hasUnderlyingType='express'.Request +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/namespaceDecls.ts b/javascript/ql/test/library-tests/UnderlyingTypes/namespaceDecls.ts new file mode 100644 index 000000000000..bd8811dfe7aa --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/namespaceDecls.ts @@ -0,0 +1,27 @@ +import Express = require('express'); + +namespace A { + export import E = Express; +} +namespace B { + export import Q = A +} +namespace C { + import E = Express; + export const A = E; +} + +function t1(x: A.E.Request) { // $ hasUnderlyingType='express'.Request +} + +function t2(x: B.Q.E.Request) { // $ hasUnderlyingType='express'.Request +} + +function t3(x: typeof Express) { // $ hasUnderlyingType='express' +} + +function t4(x: typeof A.E) { // $ hasUnderlyingType='express' +} + +function t5(x: typeof C.A) { // $ hasUnderlyingType='express' +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/namespaceImport.ts b/javascript/ql/test/library-tests/UnderlyingTypes/namespaceImport.ts new file mode 100644 index 000000000000..f2f96865f390 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/namespaceImport.ts @@ -0,0 +1,15 @@ +import * as express from 'express'; + +function t1(e: typeof express) { // $ hasUnderlyingType='express' +} + +function t2(req: express.Request) { // $ hasUnderlyingType='express'.Request +} + +function t3(req: Request) { // $ hasUnderlyingType=Request // not in scope, refers to a global +} + +type E = typeof express; + +function t4(e: E) { // $ hasUnderlyingType='express' +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/props.ts b/javascript/ql/test/library-tests/UnderlyingTypes/props.ts new file mode 100644 index 000000000000..1aded75ae95f --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/props.ts @@ -0,0 +1,16 @@ +import * as express from 'express'; + +interface Foo { + req: express.Request; + e: typeof express; +} + +function t1(f: Foo) { + f.req; // $ hasUnderlyingType='express'.Request + f.e; // $ hasUnderlyingType='express' + + const { + req, // $ hasUnderlyingType='express'.Request + e // $ hasUnderlyingType='express' + } = f; +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/subtype.ts b/javascript/ql/test/library-tests/UnderlyingTypes/subtype.ts new file mode 100644 index 000000000000..a23b85e3b81e --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/subtype.ts @@ -0,0 +1,20 @@ +import * as express from 'express'; + +interface MyRequest extends express.Request { + +} + +function t1(req: MyRequest) { // $ hasUnderlyingType='express'.Request +} + +class MyRequestClass extends express.Request { +} + +function t2(req: MyRequestClass) { // $ hasUnderlyingType='express'.Request +} + +class MyRequestClass2 implements express.Request { +} + +function t3(req: MyRequestClass2) { // $ hasUnderlyingType='express'.Request +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/test.expected b/javascript/ql/test/library-tests/UnderlyingTypes/test.expected new file mode 100644 index 000000000000..21df0c0b9210 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/test.expected @@ -0,0 +1,55 @@ +| calls.ts:6:5:6:16 | getRequest() | 'express'.Request | +| calls.ts:12:5:12:23 | getRequestAmbient() | 'express'.Request | +| calls.ts:20:5:20:14 | c.method() | 'express'.Request | +| calls.ts:21:5:21:20 | new C().method() | 'express'.Request | +| calls.ts:24:24:24:26 | req | 'express'.Request | +| calls.ts:29:9:29:11 | req | 'express'.Request | +| closure.use.js:9:13:9:13 | x | closure.lib.Foo | +| closure.use.js:9:13:9:13 | x | closure.reexported.Foo | +| closure.use.js:15:13:15:13 | x | closure.es.Bar | +| closure.use.js:15:13:15:13 | x | closure.reexported.Bar | +| contextualTypes.ts:4:12:4:14 | req | 'express'.Request | +| contextualTypes.ts:11:16:11:18 | req | 'express'.Request | +| contextualTypes.ts:18:16:18:18 | req | 'express'.Request | +| contextualTypes.ts:21:16:21:18 | req | 'express'.Request | +| contextualTypes.ts:27:16:27:18 | req | 'express'.Request | +| contextualTypes.ts:34:20:34:22 | req | 'express'.Request | +| contextualTypes.ts:41:16:41:18 | req | 'express'.Request | +| dynamicImportUse.ts:3:5:3:18 | e.getRequest() | 'express'.Request | +| expressBulkExport.use.ts:3:13:3:15 | req | 'express'.Request | +| expressBulkExport.use.ts:6:13:6:15 | res | 'express'.Response | +| expressExportAssign.use.ts:3:13:3:15 | req | 'express'.Request | +| expressExportAssignWrapper.use.ts:3:13:3:15 | req | 'express'.Request | +| expressSelectiveExport.use.ts:3:13:3:15 | req | 'express'.Request | +| expressSelectiveExport.use.ts:9:13:9:15 | res | 'express'.Response | +| expressWrapperExport.use.ts:10:13:10:15 | req | 'express'.Request | +| expressWrapperExport.use.ts:13:13:13:15 | res | 'express'.Response | +| expressWrapperExport.use.ts:16:13:16:15 | req | 'express'.Request | +| expressWrapperExport.use.ts:19:13:19:15 | res | 'express'.Response | +| expressWrapperExport.use.ts:28:13:28:13 | e | 'express' | +| globals.ts:1:13:1:14 | el | HTMLElement | +| globals.ts:6:13:6:14 | el | HTMLInputElement | +| globals.ts:9:13:9:15 | req | Express.Request | +| jsdoc.js:7:13:7:15 | req | 'express'.Request | +| jsdoc.js:13:13:13:15 | res | 'express'.Response | +| namedImport.ts:3:13:3:15 | req | 'express'.Request | +| namespaceDecls.ts:14:13:14:13 | x | 'express'.Request | +| namespaceDecls.ts:17:13:17:13 | x | 'express'.Request | +| namespaceDecls.ts:20:13:20:13 | x | 'express' | +| namespaceDecls.ts:23:13:23:13 | x | 'express' | +| namespaceDecls.ts:26:13:26:13 | x | 'express' | +| namespaceImport.ts:3:13:3:13 | e | 'express' | +| namespaceImport.ts:6:13:6:15 | req | 'express'.Request | +| namespaceImport.ts:9:13:9:15 | req | Request | +| namespaceImport.ts:14:13:14:13 | e | 'express' | +| props.ts:9:5:9:9 | f.req | 'express'.Request | +| props.ts:10:5:10:7 | f.e | 'express' | +| props.ts:13:9:13:11 | req | 'express'.Request | +| props.ts:14:9:14:9 | e | 'express' | +| subtype.ts:7:13:7:15 | req | 'express'.Request | +| subtype.ts:13:13:13:15 | req | 'express'.Request | +| subtype.ts:19:13:19:15 | req | 'express'.Request | +| typeCast.ts:4:16:4:35 | e as express.Request | 'express'.Request | +| typeCast.ts:5:16:5:33 | e | 'express'.Request | +| typeCast.ts:6:16:6:42 | e satis ... Request | 'express'.Request | +| varAssignment.ts:4:9:4:11 | req | 'express'.Request | diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/test.ql b/javascript/ql/test/library-tests/UnderlyingTypes/test.ql new file mode 100644 index 000000000000..d3074111f919 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/test.ql @@ -0,0 +1,15 @@ +import javascript + +bindingset[x, y] +private string join(string x, string y) { + if x = "" or y = "" then result = x + y else result = x + "." + y +} + +query predicate hasUnderlyingType(DataFlow::SourceNode node, string value) { + node.hasUnderlyingType(value) + or + exists(string mod, string name | + node.hasUnderlyingType(mod, name) and + value = join("'" + mod + "'", name) + ) +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/test.qlref b/javascript/ql/test/library-tests/UnderlyingTypes/test.qlref new file mode 100644 index 000000000000..ab6773f15f90 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/test.qlref @@ -0,0 +1,2 @@ +query: test.ql +postprocess: utils/test/InlineExpectationsTestQuery.ql diff --git a/javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/tsconfig.json b/javascript/ql/test/library-tests/UnderlyingTypes/tsconfig.json similarity index 100% rename from javascript/ql/test/library-tests/TypeScript/RegressionTests/GenericTypeAlias/tsconfig.json rename to javascript/ql/test/library-tests/UnderlyingTypes/tsconfig.json diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/typeCast.ts b/javascript/ql/test/library-tests/UnderlyingTypes/typeCast.ts new file mode 100644 index 000000000000..09b6105d0126 --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/typeCast.ts @@ -0,0 +1,7 @@ +import * as express from 'express'; + +function t1(e) { + var req1 = e as express.Request; // $ hasUnderlyingType='express'.Request + var req2 = e; // $ hasUnderlyingType='express'.Request + var req3 = e satisfies express.Request; // $ hasUnderlyingType='express'.Request +} diff --git a/javascript/ql/test/library-tests/UnderlyingTypes/varAssignment.ts b/javascript/ql/test/library-tests/UnderlyingTypes/varAssignment.ts new file mode 100644 index 000000000000..c7160e16561e --- /dev/null +++ b/javascript/ql/test/library-tests/UnderlyingTypes/varAssignment.ts @@ -0,0 +1,5 @@ +import * as express from 'express'; + +function t1(e) { + var req: express.Request = e; // $ hasUnderlyingType='express'.Request +} diff --git a/javascript/ql/test/library-tests/frameworks/Electron/tests.expected b/javascript/ql/test/library-tests/frameworks/Electron/tests.expected index 3050fb8fa533..72fb0a737b85 100644 --- a/javascript/ql/test/library-tests/frameworks/Electron/tests.expected +++ b/javascript/ql/test/library-tests/frameworks/Electron/tests.expected @@ -16,6 +16,8 @@ browserObject | electron.js:63:3:63:5 | win | | electron.js:65:18:65:20 | win | | electronTs.ts:3:12:3:13 | bw | +| electronTs.ts:3:12:3:13 | bw | +| electronTs.ts:3:40:3:41 | bv | | electronTs.ts:3:40:3:41 | bv | | electronTs.ts:4:3:4:4 | bw | | electronTs.ts:5:3:5:4 | bv | diff --git a/javascript/ql/test/library-tests/frameworks/Nest/test.expected b/javascript/ql/test/library-tests/frameworks/Nest/test.expected index ff12967bec69..db49fc95eba9 100644 --- a/javascript/ql/test/library-tests/frameworks/Nest/test.expected +++ b/javascript/ql/test/library-tests/frameworks/Nest/test.expected @@ -71,6 +71,9 @@ responseSendArgument | local/customPipe.ts:37:16:37:31 | '' + unsanitized | | local/customPipe.ts:42:16:42:31 | '' + unsanitized | | local/customPipe.ts:48:16:48:31 | '' + unsanitized | +| local/routes.ts:7:12:7:16 | 'foo' | +| local/routes.ts:12:12:12:16 | 'foo' | +| local/routes.ts:17:12:17:16 | 'foo' | | local/routes.ts:32:31:32:31 | x | | local/routes.ts:33:31:33:38 | queryObj | | local/routes.ts:34:31:34:34 | name | diff --git a/javascript/ql/test/query-tests/Declarations/UnreachableOverloads/UnreachableMethodOverloads.expected b/javascript/ql/test/query-tests/Declarations/UnreachableOverloads/UnreachableMethodOverloads.expected index 44bd568e7674..24767950a661 100644 --- a/javascript/ql/test/query-tests/Declarations/UnreachableOverloads/UnreachableMethodOverloads.expected +++ b/javascript/ql/test/query-tests/Declarations/UnreachableOverloads/UnreachableMethodOverloads.expected @@ -1,5 +1,2 @@ -| tst.ts:3:3:3:30 | method( ... number; | This overload of method() is unreachable, the $@ overload will always be selected. | tst.ts:2:3:2:30 | method( ... string; | previous | | tst.ts:6:3:6:17 | types1(): any[] | This overload of types1() is unreachable, the $@ overload will always be selected. | tst.ts:5:3:5:18 | types1(): T[] | previous | -| tst.ts:15:3:15:74 | on(even ... nction; | This overload of on() is unreachable, the $@ overload will always be selected. | tst.ts:14:3:14:74 | on(even ... nction; | previous | | tst.ts:21:3:21:28 | bar(thi ... number; | This overload of bar() is unreachable, the $@ overload will always be selected. | tst.ts:20:3:20:28 | bar(thi ... string; | previous | -| tst.ts:27:3:27:30 | method( ... number; | This overload of method() is unreachable, the $@ overload will always be selected. | tst.ts:26:3:26:30 | method( ... string; | previous | diff --git a/javascript/ql/test/query-tests/Declarations/UnreachableOverloads/tst.ts b/javascript/ql/test/query-tests/Declarations/UnreachableOverloads/tst.ts index 17d95f835cf7..4ffd64bc7c18 100644 --- a/javascript/ql/test/query-tests/Declarations/UnreachableOverloads/tst.ts +++ b/javascript/ql/test/query-tests/Declarations/UnreachableOverloads/tst.ts @@ -1,6 +1,6 @@ declare class Foobar { method(foo: number): string; - method(foo: number): number; // $ Alert + method(foo: number): number; // $ MISSING: Alert types1(): T[] types1(): any[] // $ Alert @@ -12,7 +12,7 @@ declare class Foobar { types3(t: T): number on(event: string, fn?: (event?: any, ...args: any[]) => void): Function; - on(event: string, fn?: (event?: any, ...args: any[]) => void): Function; // $ Alert + on(event: string, fn?: (event?: any, ...args: any[]) => void): Function; // $ MISSING: Alert foo(this: string): string; foo(this: number): number; @@ -24,7 +24,7 @@ declare class Foobar { declare class Base { method(foo: number): string; - method(foo: number): number; // $ Alert + method(foo: number): number; // $ MISSING: Alert overRiddenInSub(): string; overRiddenInSub(): number; diff --git a/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/Xss.expected b/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/Xss.expected index 6ba8ab703bff..0f5659492116 100644 --- a/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/Xss.expected +++ b/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/Xss.expected @@ -62,6 +62,8 @@ | dragAndDrop.ts:73:29:73:39 | droppedHtml | dragAndDrop.ts:71:27:71:61 | e.dataT ... /html') | dragAndDrop.ts:73:29:73:39 | droppedHtml | Cross-site scripting vulnerability due to $@. | dragAndDrop.ts:71:27:71:61 | e.dataT ... /html') | user-provided value | | event-handler-receiver.js:2:31:2:83 | '

' | event-handler-receiver.js:2:49:2:61 | location.href | event-handler-receiver.js:2:31:2:83 | '

' | Cross-site scripting vulnerability due to $@. | event-handler-receiver.js:2:49:2:61 | location.href | user-provided value | | express.js:6:15:6:33 | req.param("wobble") | express.js:6:15:6:33 | req.param("wobble") | express.js:6:15:6:33 | req.param("wobble") | Cross-site scripting vulnerability due to $@. | express.js:6:15:6:33 | req.param("wobble") | user-provided value | +| jquery-declare-any.ts:6:7:6:17 | window.name | jquery-declare-any.ts:6:7:6:17 | window.name | jquery-declare-any.ts:6:7:6:17 | window.name | Cross-site scripting vulnerability due to $@. | jquery-declare-any.ts:6:7:6:17 | window.name | user-provided value | +| jquery-declare-type.ts:6:7:6:17 | window.name | jquery-declare-type.ts:6:7:6:17 | window.name | jquery-declare-type.ts:6:7:6:17 | window.name | Cross-site scripting vulnerability due to $@. | jquery-declare-type.ts:6:7:6:17 | window.name | user-provided value | | jquery.js:7:5:7:34 | "
" | jquery.js:2:17:2:40 | documen ... .search | jquery.js:7:5:7:34 | "
" | Cross-site scripting vulnerability due to $@. | jquery.js:2:17:2:40 | documen ... .search | user-provided value | | jquery.js:8:18:8:34 | "XSS: " + tainted | jquery.js:2:17:2:40 | documen ... .search | jquery.js:8:18:8:34 | "XSS: " + tainted | Cross-site scripting vulnerability due to $@. | jquery.js:2:17:2:40 | documen ... .search | user-provided value | | jquery.js:10:5:10:40 | "" + ... "" | jquery.js:10:13:10:20 | location | jquery.js:10:5:10:40 | "" + ... "" | Cross-site scripting vulnerability due to $@. | jquery.js:10:13:10:20 | location | user-provided value | @@ -954,6 +956,8 @@ nodes | event-handler-receiver.js:2:31:2:83 | '

' | semmle.label | '

' | | event-handler-receiver.js:2:49:2:61 | location.href | semmle.label | location.href | | express.js:6:15:6:33 | req.param("wobble") | semmle.label | req.param("wobble") | +| jquery-declare-any.ts:6:7:6:17 | window.name | semmle.label | window.name | +| jquery-declare-type.ts:6:7:6:17 | window.name | semmle.label | window.name | | jquery.js:2:7:2:40 | tainted | semmle.label | tainted | | jquery.js:2:17:2:40 | documen ... .search | semmle.label | documen ... .search | | jquery.js:4:5:4:11 | tainted | semmle.label | tainted | diff --git a/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/XssWithAdditionalSources.expected b/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/XssWithAdditionalSources.expected index 0ed15b8d92ab..c031b7c1810c 100644 --- a/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/XssWithAdditionalSources.expected +++ b/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/XssWithAdditionalSources.expected @@ -182,6 +182,8 @@ nodes | hana.js:85:35:85:54 | tableRows[0].comment | semmle.label | tableRows[0].comment | | hana.js:90:33:90:34 | rs | semmle.label | rs | | hana.js:90:33:90:45 | rs[0].comment | semmle.label | rs[0].comment | +| jquery-declare-any.ts:6:7:6:17 | window.name | semmle.label | window.name | +| jquery-declare-type.ts:6:7:6:17 | window.name | semmle.label | window.name | | jquery.js:2:7:2:40 | tainted | semmle.label | tainted | | jquery.js:2:17:2:40 | documen ... .search | semmle.label | documen ... .search | | jquery.js:4:5:4:11 | tainted | semmle.label | tainted | diff --git a/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/jquery-declare-any.ts b/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/jquery-declare-any.ts new file mode 100644 index 000000000000..df8267bba306 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/jquery-declare-any.ts @@ -0,0 +1,7 @@ +import 'dummy'; + +declare var $: any; + +function t() { + $(window.name); // $ Alert +} diff --git a/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/jquery-declare-type.ts b/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/jquery-declare-type.ts new file mode 100644 index 000000000000..c866f71a1eb9 --- /dev/null +++ b/javascript/ql/test/query-tests/Security/CWE-079/DomBasedXss/jquery-declare-type.ts @@ -0,0 +1,7 @@ +import 'dummy'; + +declare var $: JQueryStatic; + +function t() { + $(window.name); // $ Alert +} diff --git a/javascript/ql/test/query-tests/Security/CWE-079/UnsafeHtmlConstruction/UnsafeHtmlConstruction.expected b/javascript/ql/test/query-tests/Security/CWE-079/UnsafeHtmlConstruction/UnsafeHtmlConstruction.expected index 499cf6cce49d..4f757d1a9313 100644 --- a/javascript/ql/test/query-tests/Security/CWE-079/UnsafeHtmlConstruction/UnsafeHtmlConstruction.expected +++ b/javascript/ql/test/query-tests/Security/CWE-079/UnsafeHtmlConstruction/UnsafeHtmlConstruction.expected @@ -22,7 +22,6 @@ | main.js:111:37:111:37 | x | main.js:98:43:98:43 | x | main.js:111:37:111:37 | x | This markdown rendering which depends on $@ might later allow $@. | main.js:98:43:98:43 | x | library input | main.js:112:24:112:26 | svg | cross-site scripting | | main.js:117:34:117:34 | s | main.js:116:47:116:47 | s | main.js:117:34:117:34 | s | This markdown rendering which depends on $@ might later allow $@. | main.js:116:47:116:47 | s | library input | main.js:118:53:118:56 | html | cross-site scripting | | typed.ts:2:29:2:29 | s | typed.ts:1:39:1:39 | s | typed.ts:2:29:2:29 | s | This HTML construction which depends on $@ might later allow $@. | typed.ts:1:39:1:39 | s | library input | typed.ts:3:31:3:34 | html | cross-site scripting | -| typed.ts:8:40:8:40 | s | typed.ts:6:43:6:43 | s | typed.ts:8:40:8:40 | s | This HTML construction which depends on $@ might later allow $@. | typed.ts:6:43:6:43 | s | library input | typed.ts:8:29:8:52 | " ... /span>" | cross-site scripting | edges | jquery-plugin.js:11:27:11:31 | stuff | jquery-plugin.js:14:31:14:35 | stuff | provenance | | | jquery-plugin.js:11:34:11:40 | options | jquery-plugin.js:12:31:12:37 | options | provenance | | @@ -69,7 +68,6 @@ edges | main.js:98:43:98:43 | x | main.js:111:37:111:37 | x | provenance | | | main.js:116:47:116:47 | s | main.js:117:34:117:34 | s | provenance | | | typed.ts:1:39:1:39 | s | typed.ts:2:29:2:29 | s | provenance | | -| typed.ts:6:43:6:43 | s | typed.ts:8:40:8:40 | s | provenance | | nodes | jquery-plugin.js:11:27:11:31 | stuff | semmle.label | stuff | | jquery-plugin.js:11:34:11:40 | options | semmle.label | options | @@ -128,6 +126,4 @@ nodes | main.js:117:34:117:34 | s | semmle.label | s | | typed.ts:1:39:1:39 | s | semmle.label | s | | typed.ts:2:29:2:29 | s | semmle.label | s | -| typed.ts:6:43:6:43 | s | semmle.label | s | -| typed.ts:8:40:8:40 | s | semmle.label | s | subpaths diff --git a/javascript/ql/test/query-tests/Security/CWE-079/UnsafeHtmlConstruction/typed.ts b/javascript/ql/test/query-tests/Security/CWE-079/UnsafeHtmlConstruction/typed.ts index 1c50460050cf..8c166fb243ff 100644 --- a/javascript/ql/test/query-tests/Security/CWE-079/UnsafeHtmlConstruction/typed.ts +++ b/javascript/ql/test/query-tests/Security/CWE-079/UnsafeHtmlConstruction/typed.ts @@ -3,9 +3,9 @@ export function basicHtmlConstruction(s: string) { // $ Source document.body.innerHTML = html; } -export function insertIntoCreatedDocument(s: string) { // $ Source +export function insertIntoCreatedDocument(s: string) { const newDoc = document.implementation.createHTMLDocument(""); - newDoc.body.innerHTML = "" + s + ""; // $ SPURIOUS: Alert - inserted into document disconnected from the main DOM. + newDoc.body.innerHTML = "" + s + ""; // OK - inserted into document disconnected from the main DOM. } export function id(s: string) { @@ -17,4 +17,3 @@ export function notVulnerable() { const html = "" + s + ""; document.body.innerHTML = html; } - \ No newline at end of file diff --git a/javascript/ql/test/query-tests/definitions/definitions.expected b/javascript/ql/test/query-tests/definitions/definitions.expected index 081db47c3faa..cb91ac6e37ce 100644 --- a/javascript/ql/test/query-tests/definitions/definitions.expected +++ b/javascript/ql/test/query-tests/definitions/definitions.expected @@ -1,36 +1,36 @@ | b.js:3:3:3:3 | x | b.js:2:7:2:7 | x | V | -| b.js:7:1:7:1 | f | b.js:1:1:5:1 | functio ... ar x;\\n} | M | -| b.js:8:1:8:1 | g | a.js:2:1:2:15 | function g() {} | M | +| b.js:7:1:7:1 | f | b.js:1:10:1:10 | f | M | +| b.js:8:1:8:1 | g | a.js:2:10:2:10 | g | M | | client.ts:1:22:1:30 | "./tslib" | tslib.ts:1:1:10:0 | | I | -| client.ts:7:19:7:19 | C | tslib.ts:1:8:3:1 | class C {\\n m() {}\\n} | T | -| client.ts:8:10:8:10 | C | client.ts:3:1:5:1 | class C {\\n m() {}\\n} | T | -| client.ts:9:16:9:16 | C | client.ts:3:1:5:1 | class C {\\n m() {}\\n} | T | -| client.ts:10:16:10:16 | C | tslib.ts:6:10:8:3 | class C ... {}\\n } | T | -| client.ts:13:25:13:25 | C | client.ts:3:1:5:1 | class C {\\n m() {}\\n} | T | -| client.ts:13:35:13:35 | C | tslib.ts:1:8:3:1 | class C {\\n m() {}\\n} | T | -| client.ts:13:47:13:47 | C | tslib.ts:6:10:8:3 | class C ... {}\\n } | T | +| client.ts:7:19:7:19 | C | tslib.ts:1:14:1:14 | C | T | +| client.ts:8:10:8:10 | C | client.ts:3:7:3:7 | C | T | +| client.ts:9:16:9:16 | C | client.ts:3:7:3:7 | C | T | +| client.ts:10:16:10:16 | C | tslib.ts:6:16:6:16 | C | T | +| client.ts:13:25:13:25 | C | client.ts:3:7:3:7 | C | T | +| client.ts:13:35:13:35 | C | tslib.ts:1:14:1:14 | C | T | +| client.ts:13:47:13:47 | C | tslib.ts:6:16:6:16 | C | T | | client.ts:14:3:14:3 | x | client.ts:13:22:13:22 | x | V | -| client.ts:14:5:14:5 | m | client.ts:4:3:4:8 | m() {} | M | +| client.ts:14:5:14:5 | m | client.ts:4:3:4:3 | m | M | | client.ts:15:3:15:3 | y | client.ts:13:28:13:28 | y | V | -| client.ts:15:5:15:5 | m | tslib.ts:2:3:2:8 | m() {} | M | +| client.ts:15:5:15:5 | m | tslib.ts:2:3:2:3 | m | M | | client.ts:16:3:16:3 | z | client.ts:13:38:13:38 | z | V | -| client.ts:16:5:16:5 | m | tslib.ts:7:5:7:10 | m() {} | M | +| client.ts:16:5:16:5 | m | tslib.ts:7:5:7:5 | m | M | | d.js:1:17:1:21 | './c' | c.js:1:1:1:20 | | I | -| d.js:10:1:10:1 | A | d.js:7:1:9:1 | functio ... = 42;\\n} | V | -| d.js:16:19:16:23 | Super | d.js:12:1:14:1 | class S ... () {}\\n} | V | +| d.js:10:1:10:1 | A | d.js:7:10:7:10 | A | V | +| d.js:16:19:16:23 | Super | d.js:12:7:12:11 | Super | V | | d.js:16:25:16:24 | args | d.js:16:25:16:24 | args | V | | d.js:20:1:20:1 | o | d.js:3:9:5:1 | {\\n f: ... () {}\\n} | V | | d.js:20:3:20:3 | f | d.js:4:3:4:18 | f: function() {} | M | -| d.js:22:13:22:13 | A | d.js:7:1:9:1 | functio ... = 42;\\n} | M | +| d.js:22:13:22:13 | A | d.js:7:10:7:10 | A | M | | d.js:23:1:23:1 | a | d.js:22:5:22:5 | a | V | | d.js:23:3:23:3 | x | d.js:8:3:8:8 | this.x | M | | d.js:24:1:24:1 | a | d.js:22:5:22:5 | a | V | | d.js:24:3:24:3 | g | d.js:10:1:10:13 | A.prototype.g | M | -| d.js:26:13:26:15 | Sub | d.js:16:1:18:1 | class S ... () {}\\n} | M | +| d.js:26:13:26:15 | Sub | d.js:16:7:16:9 | Sub | M | | d.js:27:1:27:1 | x | d.js:26:5:26:5 | x | V | | d.js:27:3:27:3 | m | d.js:13:3:13:3 | m | M | | d.js:28:1:28:1 | x | d.js:26:5:26:5 | x | V | | d.js:28:3:28:3 | n | d.js:17:3:17:3 | n | M | | tst.js:1:19:1:23 | './m' | m.js:1:1:2:0 | | I | -| tst.js:3:5:3:5 | A | m.js:1:8:1:17 | class A {} | M | +| tst.js:3:5:3:5 | A | m.js:1:14:1:14 | A | M | | tst.js:5:15:5:19 | './m' | m.js:1:1:2:0 | | I |