mirror of
https://github.com/github/codeql.git
synced 2025-12-17 09:13:20 +01:00
1726 lines
73 KiB
Plaintext
1726 lines
73 KiB
Plaintext
test.kt:
|
|
# 0| [CompilationUnit] test
|
|
# 0| 1: [Class] TestKt
|
|
# 1| 1: [Method] sink
|
|
# 1| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 1| 0: [Parameter] a
|
|
# 1| 0: [TypeAccess] Object
|
|
# 1| 5: [BlockStmt] { ... }
|
|
# 184| 2: [Method] varargsTest
|
|
# 184| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 184| 0: [Parameter] x
|
|
# 184| 0: [TypeAccess] String
|
|
# 184| 1: [Parameter] y
|
|
# 184| 0: [TypeAccess] String[]
|
|
# 184| 0: [WildcardTypeAccess] ? ...
|
|
# 184| 0: [TypeAccess] String
|
|
# 184| 2: [Parameter] z
|
|
# 184| 0: [TypeAccess] String
|
|
# 184| 5: [BlockStmt] { ... }
|
|
# 185| 0: [ExprStmt] <Expr>;
|
|
# 185| 0: [MethodCall] sink(...)
|
|
# 185| -1: [TypeAccess] TestKt
|
|
# 185| 0: [VarAccess] x
|
|
# 186| 1: [ExprStmt] <Expr>;
|
|
# 186| 0: [MethodCall] sink(...)
|
|
# 186| -1: [TypeAccess] TestKt
|
|
# 186| 0: [ArrayAccess] ...[...]
|
|
# 186| 0: [VarAccess] y
|
|
# 186| 1: [IntegerLiteral] 0
|
|
# 187| 2: [ExprStmt] <Expr>;
|
|
# 187| 0: [MethodCall] sink(...)
|
|
# 187| -1: [TypeAccess] TestKt
|
|
# 187| 0: [VarAccess] z
|
|
# 184| 3: [Method] varargsTest$default
|
|
# 184| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 184| 0: [Parameter] p0
|
|
# 184| 0: [TypeAccess] String
|
|
# 184| 1: [Parameter] p1
|
|
# 184| 0: [TypeAccess] String[]
|
|
# 184| 2: [Parameter] p2
|
|
# 184| 0: [TypeAccess] String
|
|
# 184| 3: [Parameter] p3
|
|
# 184| 0: [TypeAccess] int
|
|
# 184| 4: [Parameter] p4
|
|
# 184| 0: [TypeAccess] Object
|
|
# 184| 5: [BlockStmt] { ... }
|
|
# 184| 0: [IfStmt] if (...)
|
|
# 184| 0: [EQExpr] ... == ...
|
|
# 184| 0: [AndBitwiseExpr] ... & ...
|
|
# 184| 0: [IntegerLiteral] 1
|
|
# 184| 1: [VarAccess] p3
|
|
# 184| 1: [IntegerLiteral] 0
|
|
# 184| 1: [ExprStmt] <Expr>;
|
|
# 184| 0: [AssignExpr] ...=...
|
|
# 184| 0: [VarAccess] p0
|
|
# 184| 1: [StringLiteral] "before-vararg-default sunk"
|
|
# 184| 1: [IfStmt] if (...)
|
|
# 184| 0: [EQExpr] ... == ...
|
|
# 184| 0: [AndBitwiseExpr] ... & ...
|
|
# 184| 0: [IntegerLiteral] 2
|
|
# 184| 1: [VarAccess] p3
|
|
# 184| 1: [IntegerLiteral] 0
|
|
# 184| 1: [ExprStmt] <Expr>;
|
|
# 184| 0: [AssignExpr] ...=...
|
|
# 184| 0: [VarAccess] p1
|
|
# 184| 1: [ArrayCreationExpr] new String[]
|
|
# 184| -2: [ArrayInit] {...}
|
|
# 184| 0: [StringLiteral] "first-vararg-default sunk"
|
|
# 184| 1: [StringLiteral] "second-vararg-default sunk"
|
|
# 184| -1: [TypeAccess] String
|
|
# 184| 0: [IntegerLiteral] 2
|
|
# 184| 2: [IfStmt] if (...)
|
|
# 184| 0: [EQExpr] ... == ...
|
|
# 184| 0: [AndBitwiseExpr] ... & ...
|
|
# 184| 0: [IntegerLiteral] 4
|
|
# 184| 1: [VarAccess] p3
|
|
# 184| 1: [IntegerLiteral] 0
|
|
# 184| 1: [ExprStmt] <Expr>;
|
|
# 184| 0: [AssignExpr] ...=...
|
|
# 184| 0: [VarAccess] p2
|
|
# 184| 1: [StringLiteral] "after-vararg-default sunk"
|
|
# 184| 3: [ReturnStmt] return ...
|
|
# 184| 0: [MethodCall] varargsTest(...)
|
|
# 184| -1: [TypeAccess] TestKt
|
|
# 184| 0: [VarAccess] p0
|
|
# 184| 1: [VarAccess] p1
|
|
# 184| 2: [VarAccess] p2
|
|
# 190| 4: [Method] varargsUser
|
|
# 190| 3: [TypeAccess] Unit
|
|
# 190| 5: [BlockStmt] { ... }
|
|
# 191| 0: [ExprStmt] <Expr>;
|
|
# 191| 0: [MethodCall] varargsTest$default(...)
|
|
# 191| -1: [TypeAccess] TestKt
|
|
# 1| 0: [NullLiteral] null
|
|
# 1| 1: [NullLiteral] null
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 0
|
|
# 1| 4: [NullLiteral] null
|
|
# 192| 1: [ExprStmt] <Expr>;
|
|
# 192| 0: [MethodCall] varargsTest$default(...)
|
|
# 192| -1: [TypeAccess] TestKt
|
|
# 192| 0: [StringLiteral] "no-varargs-before, no-z-parameter sunk"
|
|
# 1| 1: [NullLiteral] null
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 1
|
|
# 1| 4: [NullLiteral] null
|
|
# 193| 2: [ExprStmt] <Expr>;
|
|
# 193| 0: [MethodCall] varargsTest$default(...)
|
|
# 193| -1: [TypeAccess] TestKt
|
|
# 193| 0: [StringLiteral] "no-varargs-before sunk"
|
|
# 1| 1: [NullLiteral] null
|
|
# 193| 2: [StringLiteral] "no-varargs-after sunk"
|
|
# 1| 3: [IntegerLiteral] 5
|
|
# 1| 4: [NullLiteral] null
|
|
# 194| 3: [ExprStmt] <Expr>;
|
|
# 194| 0: [MethodCall] varargsTest(...)
|
|
# 194| -1: [TypeAccess] TestKt
|
|
# 194| 0: [StringLiteral] "one-vararg-before sunk"
|
|
# 194| 1: [StringLiteral] "one-vararg sunk"
|
|
# 194| 2: [StringLiteral] "one-vararg-after sunk"
|
|
# 195| 4: [ExprStmt] <Expr>;
|
|
# 195| 0: [MethodCall] varargsTest(...)
|
|
# 195| -1: [TypeAccess] TestKt
|
|
# 195| 0: [StringLiteral] "two-varargs-before sunk"
|
|
# 195| 1: [StringLiteral] "two-vararg-first sunk"
|
|
# 195| 2: [StringLiteral] "two-vararg-second sunk"
|
|
# 195| 3: [StringLiteral] "two-varargs-after sunk"
|
|
# 196| 5: [ExprStmt] <Expr>;
|
|
# 196| 0: [MethodCall] varargsTest$default(...)
|
|
# 196| -1: [TypeAccess] TestKt
|
|
# 196| 0: [StringLiteral] "no-z-parmeter sunk"
|
|
# 196| 1: [ArrayCreationExpr] new String[]
|
|
# 196| -2: [ArrayInit] {...}
|
|
# 196| 0: [StringLiteral] "no-z-parameter first vararg sunk"
|
|
# 196| 1: [StringLiteral] "no-z-parameter second vararg sunk"
|
|
# 196| -1: [TypeAccess] String
|
|
# 196| 0: [IntegerLiteral] 2
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 3
|
|
# 1| 4: [NullLiteral] null
|
|
# 199| 5: [Method] varargsTestOnlySinkVarargs
|
|
# 199| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 199| 0: [Parameter] x
|
|
# 199| 0: [TypeAccess] String
|
|
# 199| 1: [Parameter] y
|
|
# 199| 0: [TypeAccess] String[]
|
|
# 199| 0: [WildcardTypeAccess] ? ...
|
|
# 199| 0: [TypeAccess] String
|
|
# 199| 2: [Parameter] z
|
|
# 199| 0: [TypeAccess] String
|
|
# 199| 5: [BlockStmt] { ... }
|
|
# 200| 0: [ExprStmt] <Expr>;
|
|
# 200| 0: [MethodCall] sink(...)
|
|
# 200| -1: [TypeAccess] TestKt
|
|
# 200| 0: [ArrayAccess] ...[...]
|
|
# 200| 0: [VarAccess] y
|
|
# 200| 1: [IntegerLiteral] 0
|
|
# 199| 6: [Method] varargsTestOnlySinkVarargs$default
|
|
# 199| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 199| 0: [Parameter] p0
|
|
# 199| 0: [TypeAccess] String
|
|
# 199| 1: [Parameter] p1
|
|
# 199| 0: [TypeAccess] String[]
|
|
# 199| 2: [Parameter] p2
|
|
# 199| 0: [TypeAccess] String
|
|
# 199| 3: [Parameter] p3
|
|
# 199| 0: [TypeAccess] int
|
|
# 199| 4: [Parameter] p4
|
|
# 199| 0: [TypeAccess] Object
|
|
# 199| 5: [BlockStmt] { ... }
|
|
# 199| 0: [IfStmt] if (...)
|
|
# 199| 0: [EQExpr] ... == ...
|
|
# 199| 0: [AndBitwiseExpr] ... & ...
|
|
# 199| 0: [IntegerLiteral] 1
|
|
# 199| 1: [VarAccess] p3
|
|
# 199| 1: [IntegerLiteral] 0
|
|
# 199| 1: [ExprStmt] <Expr>;
|
|
# 199| 0: [AssignExpr] ...=...
|
|
# 199| 0: [VarAccess] p0
|
|
# 199| 1: [StringLiteral] "before-vararg-default not sunk 2"
|
|
# 199| 1: [IfStmt] if (...)
|
|
# 199| 0: [EQExpr] ... == ...
|
|
# 199| 0: [AndBitwiseExpr] ... & ...
|
|
# 199| 0: [IntegerLiteral] 2
|
|
# 199| 1: [VarAccess] p3
|
|
# 199| 1: [IntegerLiteral] 0
|
|
# 199| 1: [ExprStmt] <Expr>;
|
|
# 199| 0: [AssignExpr] ...=...
|
|
# 199| 0: [VarAccess] p1
|
|
# 199| 1: [ArrayCreationExpr] new String[]
|
|
# 199| -2: [ArrayInit] {...}
|
|
# 199| 0: [StringLiteral] "first-vararg-default sunk 2"
|
|
# 199| 1: [StringLiteral] "second-vararg-default sunk 2"
|
|
# 199| -1: [TypeAccess] String
|
|
# 199| 0: [IntegerLiteral] 2
|
|
# 199| 2: [IfStmt] if (...)
|
|
# 199| 0: [EQExpr] ... == ...
|
|
# 199| 0: [AndBitwiseExpr] ... & ...
|
|
# 199| 0: [IntegerLiteral] 4
|
|
# 199| 1: [VarAccess] p3
|
|
# 199| 1: [IntegerLiteral] 0
|
|
# 199| 1: [ExprStmt] <Expr>;
|
|
# 199| 0: [AssignExpr] ...=...
|
|
# 199| 0: [VarAccess] p2
|
|
# 199| 1: [StringLiteral] "after-vararg-default not sunk 2"
|
|
# 199| 3: [ReturnStmt] return ...
|
|
# 199| 0: [MethodCall] varargsTestOnlySinkVarargs(...)
|
|
# 199| -1: [TypeAccess] TestKt
|
|
# 199| 0: [VarAccess] p0
|
|
# 199| 1: [VarAccess] p1
|
|
# 199| 2: [VarAccess] p2
|
|
# 203| 7: [Method] varargsUserOnlySinkVarargs
|
|
# 203| 3: [TypeAccess] Unit
|
|
# 203| 5: [BlockStmt] { ... }
|
|
# 204| 0: [ExprStmt] <Expr>;
|
|
# 204| 0: [MethodCall] varargsTestOnlySinkVarargs$default(...)
|
|
# 204| -1: [TypeAccess] TestKt
|
|
# 1| 0: [NullLiteral] null
|
|
# 1| 1: [NullLiteral] null
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 0
|
|
# 1| 4: [NullLiteral] null
|
|
# 205| 1: [ExprStmt] <Expr>;
|
|
# 205| 0: [MethodCall] varargsTestOnlySinkVarargs$default(...)
|
|
# 205| -1: [TypeAccess] TestKt
|
|
# 205| 0: [StringLiteral] "no-varargs-before, no-z-parameter not sunk 2"
|
|
# 1| 1: [NullLiteral] null
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 1
|
|
# 1| 4: [NullLiteral] null
|
|
# 206| 2: [ExprStmt] <Expr>;
|
|
# 206| 0: [MethodCall] varargsTestOnlySinkVarargs$default(...)
|
|
# 206| -1: [TypeAccess] TestKt
|
|
# 206| 0: [StringLiteral] "no-varargs-before not sunk 2"
|
|
# 1| 1: [NullLiteral] null
|
|
# 206| 2: [StringLiteral] "no-varargs-after not sunk 2"
|
|
# 1| 3: [IntegerLiteral] 5
|
|
# 1| 4: [NullLiteral] null
|
|
# 207| 3: [ExprStmt] <Expr>;
|
|
# 207| 0: [MethodCall] varargsTestOnlySinkVarargs(...)
|
|
# 207| -1: [TypeAccess] TestKt
|
|
# 207| 0: [StringLiteral] "one-vararg-before not sunk 2"
|
|
# 207| 1: [StringLiteral] "one-vararg sunk 2"
|
|
# 207| 2: [StringLiteral] "one-vararg-after not sunk 2"
|
|
# 208| 4: [ExprStmt] <Expr>;
|
|
# 208| 0: [MethodCall] varargsTestOnlySinkVarargs(...)
|
|
# 208| -1: [TypeAccess] TestKt
|
|
# 208| 0: [StringLiteral] "two-varargs-before not sunk 2"
|
|
# 208| 1: [StringLiteral] "two-vararg-first sunk 2"
|
|
# 208| 2: [StringLiteral] "two-vararg-second sunk 2"
|
|
# 208| 3: [StringLiteral] "two-varargs-after not sunk 2"
|
|
# 209| 5: [ExprStmt] <Expr>;
|
|
# 209| 0: [MethodCall] varargsTestOnlySinkVarargs$default(...)
|
|
# 209| -1: [TypeAccess] TestKt
|
|
# 209| 0: [StringLiteral] "no-z-parmeter not sunk 2"
|
|
# 209| 1: [ArrayCreationExpr] new String[]
|
|
# 209| -2: [ArrayInit] {...}
|
|
# 209| 0: [StringLiteral] "no-z-parameter first vararg sunk 2"
|
|
# 209| 1: [StringLiteral] "no-z-parameter second vararg sunk 2"
|
|
# 209| -1: [TypeAccess] String
|
|
# 209| 0: [IntegerLiteral] 2
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 3
|
|
# 1| 4: [NullLiteral] null
|
|
# 212| 8: [Method] varargsTestOnlySinkRegularArgs
|
|
# 212| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 212| 0: [Parameter] x
|
|
# 212| 0: [TypeAccess] String
|
|
# 212| 1: [Parameter] y
|
|
# 212| 0: [TypeAccess] String[]
|
|
# 212| 0: [WildcardTypeAccess] ? ...
|
|
# 212| 0: [TypeAccess] String
|
|
# 212| 2: [Parameter] z
|
|
# 212| 0: [TypeAccess] String
|
|
# 212| 5: [BlockStmt] { ... }
|
|
# 213| 0: [ExprStmt] <Expr>;
|
|
# 213| 0: [MethodCall] sink(...)
|
|
# 213| -1: [TypeAccess] TestKt
|
|
# 213| 0: [VarAccess] x
|
|
# 214| 1: [ExprStmt] <Expr>;
|
|
# 214| 0: [MethodCall] sink(...)
|
|
# 214| -1: [TypeAccess] TestKt
|
|
# 214| 0: [VarAccess] z
|
|
# 212| 9: [Method] varargsTestOnlySinkRegularArgs$default
|
|
# 212| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 212| 0: [Parameter] p0
|
|
# 212| 0: [TypeAccess] String
|
|
# 212| 1: [Parameter] p1
|
|
# 212| 0: [TypeAccess] String[]
|
|
# 212| 2: [Parameter] p2
|
|
# 212| 0: [TypeAccess] String
|
|
# 212| 3: [Parameter] p3
|
|
# 212| 0: [TypeAccess] int
|
|
# 212| 4: [Parameter] p4
|
|
# 212| 0: [TypeAccess] Object
|
|
# 212| 5: [BlockStmt] { ... }
|
|
# 212| 0: [IfStmt] if (...)
|
|
# 212| 0: [EQExpr] ... == ...
|
|
# 212| 0: [AndBitwiseExpr] ... & ...
|
|
# 212| 0: [IntegerLiteral] 1
|
|
# 212| 1: [VarAccess] p3
|
|
# 212| 1: [IntegerLiteral] 0
|
|
# 212| 1: [ExprStmt] <Expr>;
|
|
# 212| 0: [AssignExpr] ...=...
|
|
# 212| 0: [VarAccess] p0
|
|
# 212| 1: [StringLiteral] "before-vararg-default sunk 3"
|
|
# 212| 1: [IfStmt] if (...)
|
|
# 212| 0: [EQExpr] ... == ...
|
|
# 212| 0: [AndBitwiseExpr] ... & ...
|
|
# 212| 0: [IntegerLiteral] 2
|
|
# 212| 1: [VarAccess] p3
|
|
# 212| 1: [IntegerLiteral] 0
|
|
# 212| 1: [ExprStmt] <Expr>;
|
|
# 212| 0: [AssignExpr] ...=...
|
|
# 212| 0: [VarAccess] p1
|
|
# 212| 1: [ArrayCreationExpr] new String[]
|
|
# 212| -2: [ArrayInit] {...}
|
|
# 212| 0: [StringLiteral] "first-vararg-default not sunk 3"
|
|
# 212| 1: [StringLiteral] "second-vararg-default not sunk 3"
|
|
# 212| -1: [TypeAccess] String
|
|
# 212| 0: [IntegerLiteral] 2
|
|
# 212| 2: [IfStmt] if (...)
|
|
# 212| 0: [EQExpr] ... == ...
|
|
# 212| 0: [AndBitwiseExpr] ... & ...
|
|
# 212| 0: [IntegerLiteral] 4
|
|
# 212| 1: [VarAccess] p3
|
|
# 212| 1: [IntegerLiteral] 0
|
|
# 212| 1: [ExprStmt] <Expr>;
|
|
# 212| 0: [AssignExpr] ...=...
|
|
# 212| 0: [VarAccess] p2
|
|
# 212| 1: [StringLiteral] "after-vararg-default sunk 3"
|
|
# 212| 3: [ReturnStmt] return ...
|
|
# 212| 0: [MethodCall] varargsTestOnlySinkRegularArgs(...)
|
|
# 212| -1: [TypeAccess] TestKt
|
|
# 212| 0: [VarAccess] p0
|
|
# 212| 1: [VarAccess] p1
|
|
# 212| 2: [VarAccess] p2
|
|
# 217| 10: [Method] varargsUserOnlySinkRegularArgs
|
|
# 217| 3: [TypeAccess] Unit
|
|
# 217| 5: [BlockStmt] { ... }
|
|
# 218| 0: [ExprStmt] <Expr>;
|
|
# 218| 0: [MethodCall] varargsTestOnlySinkRegularArgs$default(...)
|
|
# 218| -1: [TypeAccess] TestKt
|
|
# 1| 0: [NullLiteral] null
|
|
# 1| 1: [NullLiteral] null
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 0
|
|
# 1| 4: [NullLiteral] null
|
|
# 219| 1: [ExprStmt] <Expr>;
|
|
# 219| 0: [MethodCall] varargsTestOnlySinkRegularArgs$default(...)
|
|
# 219| -1: [TypeAccess] TestKt
|
|
# 219| 0: [StringLiteral] "no-varargs-before, no-z-parameter sunk 3"
|
|
# 1| 1: [NullLiteral] null
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 1
|
|
# 1| 4: [NullLiteral] null
|
|
# 220| 2: [ExprStmt] <Expr>;
|
|
# 220| 0: [MethodCall] varargsTestOnlySinkRegularArgs$default(...)
|
|
# 220| -1: [TypeAccess] TestKt
|
|
# 220| 0: [StringLiteral] "no-varargs-before sunk 3"
|
|
# 1| 1: [NullLiteral] null
|
|
# 220| 2: [StringLiteral] "no-varargs-after sunk 3"
|
|
# 1| 3: [IntegerLiteral] 5
|
|
# 1| 4: [NullLiteral] null
|
|
# 221| 3: [ExprStmt] <Expr>;
|
|
# 221| 0: [MethodCall] varargsTestOnlySinkRegularArgs(...)
|
|
# 221| -1: [TypeAccess] TestKt
|
|
# 221| 0: [StringLiteral] "one-vararg-before sunk 3"
|
|
# 221| 1: [StringLiteral] "one-vararg not sunk 3"
|
|
# 221| 2: [StringLiteral] "one-vararg-after sunk 3"
|
|
# 222| 4: [ExprStmt] <Expr>;
|
|
# 222| 0: [MethodCall] varargsTestOnlySinkRegularArgs(...)
|
|
# 222| -1: [TypeAccess] TestKt
|
|
# 222| 0: [StringLiteral] "two-varargs-before sunk 3"
|
|
# 222| 1: [StringLiteral] "two-vararg-first not sunk 3"
|
|
# 222| 2: [StringLiteral] "two-vararg-second not sunk 3"
|
|
# 222| 3: [StringLiteral] "two-varargs-after sunk 3"
|
|
# 223| 5: [ExprStmt] <Expr>;
|
|
# 223| 0: [MethodCall] varargsTestOnlySinkRegularArgs$default(...)
|
|
# 223| -1: [TypeAccess] TestKt
|
|
# 223| 0: [StringLiteral] "no-z-parmeter sunk 3"
|
|
# 223| 1: [ArrayCreationExpr] new String[]
|
|
# 223| -2: [ArrayInit] {...}
|
|
# 223| 0: [StringLiteral] "no-z-parameter first vararg not sunk 3"
|
|
# 223| 1: [StringLiteral] "no-z-parameter second vararg not sunk 3"
|
|
# 223| -1: [TypeAccess] String
|
|
# 223| 0: [IntegerLiteral] 2
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 3
|
|
# 1| 4: [NullLiteral] null
|
|
# 232| 11: [Method] varargsConstructorUser
|
|
# 232| 3: [TypeAccess] Unit
|
|
# 232| 5: [BlockStmt] { ... }
|
|
# 233| 0: [ExprStmt] <Expr>;
|
|
# 233| 0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
|
|
# 233| 0: [TypeAccess] Unit
|
|
# 233| 1: [ClassInstanceExpr] new VarargsConstructorTest(...)
|
|
# 233| -3: [TypeAccess] VarargsConstructorTest
|
|
# 233| 0: [StringLiteral] "varargs constructor test sunk"
|
|
# 234| 1: [ExprStmt] <Expr>;
|
|
# 234| 0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
|
|
# 234| 0: [TypeAccess] Unit
|
|
# 234| 1: [ClassInstanceExpr] new VarargsConstructorTest(...)
|
|
# 234| -3: [TypeAccess] VarargsConstructorTest
|
|
# 234| 0: [StringLiteral] "varargs constructor test sunk 2"
|
|
# 234| 1: [StringLiteral] "varargs constructor test not sunk 1"
|
|
# 234| 2: [StringLiteral] "varargs constructor test not sunk 2"
|
|
# 3| 2: [Class] TestMember
|
|
# 3| 1: [Constructor] TestMember
|
|
# 3| 5: [BlockStmt] { ... }
|
|
# 3| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 3| 1: [BlockStmt] { ... }
|
|
# 5| 2: [Method] f
|
|
# 5| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 5| 0: [Parameter] x
|
|
# 5| 0: [TypeAccess] String
|
|
# 5| 1: [Parameter] y
|
|
# 5| 0: [TypeAccess] String
|
|
# 5| 2: [Parameter] z
|
|
# 5| 0: [TypeAccess] String
|
|
# 5| 5: [BlockStmt] { ... }
|
|
# 6| 0: [ExprStmt] <Expr>;
|
|
# 6| 0: [MethodCall] sink(...)
|
|
# 6| -1: [TypeAccess] TestKt
|
|
# 6| 0: [VarAccess] y
|
|
# 5| 3: [Method] f$default
|
|
# 5| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 5| 0: [Parameter] p0
|
|
# 5| 0: [TypeAccess] TestMember
|
|
# 5| 1: [Parameter] p1
|
|
# 5| 0: [TypeAccess] String
|
|
# 5| 2: [Parameter] p2
|
|
# 5| 0: [TypeAccess] String
|
|
# 5| 3: [Parameter] p3
|
|
# 5| 0: [TypeAccess] String
|
|
# 5| 4: [Parameter] p4
|
|
# 5| 0: [TypeAccess] int
|
|
# 5| 5: [Parameter] p5
|
|
# 5| 0: [TypeAccess] Object
|
|
# 5| 5: [BlockStmt] { ... }
|
|
# 5| 0: [IfStmt] if (...)
|
|
# 5| 0: [EQExpr] ... == ...
|
|
# 5| 0: [AndBitwiseExpr] ... & ...
|
|
# 5| 0: [IntegerLiteral] 2
|
|
# 5| 1: [VarAccess] p4
|
|
# 5| 1: [IntegerLiteral] 0
|
|
# 5| 1: [ExprStmt] <Expr>;
|
|
# 5| 0: [AssignExpr] ...=...
|
|
# 5| 0: [VarAccess] p2
|
|
# 5| 1: [VarAccess] p1
|
|
# 5| 1: [IfStmt] if (...)
|
|
# 5| 0: [EQExpr] ... == ...
|
|
# 5| 0: [AndBitwiseExpr] ... & ...
|
|
# 5| 0: [IntegerLiteral] 4
|
|
# 5| 1: [VarAccess] p4
|
|
# 5| 1: [IntegerLiteral] 0
|
|
# 5| 1: [ExprStmt] <Expr>;
|
|
# 5| 0: [AssignExpr] ...=...
|
|
# 5| 0: [VarAccess] p3
|
|
# 5| 1: [StringLiteral] "hello world"
|
|
# 5| 2: [ReturnStmt] return ...
|
|
# 5| 0: [MethodCall] f(...)
|
|
# 5| -1: [VarAccess] p0
|
|
# 5| 0: [VarAccess] p1
|
|
# 5| 1: [VarAccess] p2
|
|
# 5| 2: [VarAccess] p3
|
|
# 9| 4: [Method] user
|
|
# 9| 3: [TypeAccess] Unit
|
|
# 9| 5: [BlockStmt] { ... }
|
|
# 10| 0: [ExprStmt] <Expr>;
|
|
# 10| 0: [MethodCall] f$default(...)
|
|
# 10| -1: [TypeAccess] TestMember
|
|
# 10| 0: [ThisAccess] this
|
|
# 10| 1: [StringLiteral] "member sunk"
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [IntegerLiteral] 1
|
|
# 1| 5: [NullLiteral] null
|
|
# 11| 1: [ExprStmt] <Expr>;
|
|
# 11| 0: [MethodCall] f$default(...)
|
|
# 11| -1: [TypeAccess] TestMember
|
|
# 11| 0: [ThisAccess] this
|
|
# 11| 1: [StringLiteral] "member sunk fp"
|
|
# 11| 2: [StringLiteral] "member sunk 2"
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [IntegerLiteral] 3
|
|
# 1| 5: [NullLiteral] null
|
|
# 12| 2: [ExprStmt] <Expr>;
|
|
# 12| 0: [MethodCall] f(...)
|
|
# 12| -1: [ThisAccess] this
|
|
# 12| 0: [StringLiteral] "not sunk"
|
|
# 12| 1: [StringLiteral] "member sunk 3"
|
|
# 12| 2: [StringLiteral] "not sunk"
|
|
# 17| 3: [Class] TestExtensionMember
|
|
# 17| 1: [Constructor] TestExtensionMember
|
|
# 17| 5: [BlockStmt] { ... }
|
|
# 17| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 17| 1: [BlockStmt] { ... }
|
|
# 19| 2: [ExtensionMethod] f
|
|
# 19| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 19| 0: [Parameter] <this>
|
|
# 19| 0: [TypeAccess] String
|
|
# 19| 1: [Parameter] x
|
|
# 19| 0: [TypeAccess] String
|
|
# 19| 2: [Parameter] y
|
|
# 19| 0: [TypeAccess] String
|
|
# 19| 3: [Parameter] z
|
|
# 19| 0: [TypeAccess] String
|
|
# 19| 5: [BlockStmt] { ... }
|
|
# 20| 0: [ExprStmt] <Expr>;
|
|
# 20| 0: [MethodCall] sink(...)
|
|
# 20| -1: [TypeAccess] TestKt
|
|
# 20| 0: [ExtensionReceiverAccess] this
|
|
# 21| 1: [ExprStmt] <Expr>;
|
|
# 21| 0: [MethodCall] sink(...)
|
|
# 21| -1: [TypeAccess] TestKt
|
|
# 21| 0: [VarAccess] y
|
|
# 19| 3: [ExtensionMethod] f$default
|
|
# 19| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 19| 0: [Parameter] p0
|
|
# 19| 0: [TypeAccess] TestExtensionMember
|
|
# 19| 1: [Parameter] p1
|
|
# 19| 0: [TypeAccess] String
|
|
# 19| 2: [Parameter] p2
|
|
# 19| 0: [TypeAccess] String
|
|
# 19| 3: [Parameter] p3
|
|
# 19| 0: [TypeAccess] String
|
|
# 19| 4: [Parameter] p4
|
|
# 19| 0: [TypeAccess] String
|
|
# 19| 5: [Parameter] p5
|
|
# 19| 0: [TypeAccess] int
|
|
# 19| 6: [Parameter] p6
|
|
# 19| 0: [TypeAccess] Object
|
|
# 19| 5: [BlockStmt] { ... }
|
|
# 19| 0: [IfStmt] if (...)
|
|
# 19| 0: [EQExpr] ... == ...
|
|
# 19| 0: [AndBitwiseExpr] ... & ...
|
|
# 19| 0: [IntegerLiteral] 2
|
|
# 19| 1: [VarAccess] p5
|
|
# 19| 1: [IntegerLiteral] 0
|
|
# 19| 1: [ExprStmt] <Expr>;
|
|
# 19| 0: [AssignExpr] ...=...
|
|
# 19| 0: [VarAccess] p3
|
|
# 19| 1: [VarAccess] p2
|
|
# 19| 1: [IfStmt] if (...)
|
|
# 19| 0: [EQExpr] ... == ...
|
|
# 19| 0: [AndBitwiseExpr] ... & ...
|
|
# 19| 0: [IntegerLiteral] 4
|
|
# 19| 1: [VarAccess] p5
|
|
# 19| 1: [IntegerLiteral] 0
|
|
# 19| 1: [ExprStmt] <Expr>;
|
|
# 19| 0: [AssignExpr] ...=...
|
|
# 19| 0: [VarAccess] p4
|
|
# 19| 1: [StringLiteral] "hello world"
|
|
# 19| 2: [ReturnStmt] return ...
|
|
# 19| 0: [MethodCall] f(...)
|
|
# 19| -1: [VarAccess] p0
|
|
# 19| 0: [ExtensionReceiverAccess] this
|
|
# 19| 1: [VarAccess] p2
|
|
# 19| 2: [VarAccess] p3
|
|
# 19| 3: [VarAccess] p4
|
|
# 24| 4: [Method] user
|
|
# 24| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 24| 0: [Parameter] sunk
|
|
# 24| 0: [TypeAccess] String
|
|
# 24| 5: [BlockStmt] { ... }
|
|
# 25| 0: [ExprStmt] <Expr>;
|
|
# 25| 0: [MethodCall] f$default(...)
|
|
# 25| -1: [TypeAccess] TestExtensionMember
|
|
# 25| 0: [ThisAccess] this
|
|
# 25| 1: [VarAccess] sunk
|
|
# 25| 2: [StringLiteral] "extension sunk"
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [NullLiteral] null
|
|
# 1| 5: [IntegerLiteral] 1
|
|
# 1| 6: [NullLiteral] null
|
|
# 26| 1: [ExprStmt] <Expr>;
|
|
# 26| 0: [MethodCall] f$default(...)
|
|
# 26| -1: [TypeAccess] TestExtensionMember
|
|
# 26| 0: [ThisAccess] this
|
|
# 26| 1: [VarAccess] sunk
|
|
# 26| 2: [StringLiteral] "extension sunk fp"
|
|
# 26| 3: [StringLiteral] "extension sunk 2"
|
|
# 1| 4: [NullLiteral] null
|
|
# 1| 5: [IntegerLiteral] 3
|
|
# 1| 6: [NullLiteral] null
|
|
# 27| 2: [ExprStmt] <Expr>;
|
|
# 27| 0: [MethodCall] f(...)
|
|
# 27| -1: [ThisAccess] this
|
|
# 27| 0: [VarAccess] sunk
|
|
# 27| 1: [StringLiteral] "not sunk"
|
|
# 27| 2: [StringLiteral] "extension sunk 3"
|
|
# 27| 3: [StringLiteral] "not sunk"
|
|
# 32| 4: [Class] TestStaticMember
|
|
# 32| 1: [Constructor] TestStaticMember
|
|
# 32| 5: [BlockStmt] { ... }
|
|
# 32| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 32| 1: [BlockStmt] { ... }
|
|
# 34| 2: [Method] f
|
|
#-----| 1: (Annotations)
|
|
# 34| 1: [Annotation] JvmStatic
|
|
# 34| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 34| 0: [Parameter] x
|
|
# 34| 0: [TypeAccess] String
|
|
# 34| 1: [Parameter] y
|
|
# 34| 0: [TypeAccess] String
|
|
# 34| 2: [Parameter] z
|
|
# 34| 0: [TypeAccess] String
|
|
# 34| 5: [BlockStmt] { ... }
|
|
# 35| 0: [ExprStmt] <Expr>;
|
|
# 35| 0: [MethodCall] sink(...)
|
|
# 35| -1: [TypeAccess] TestKt
|
|
# 35| 0: [VarAccess] y
|
|
# 34| 3: [Method] f$default
|
|
# 34| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 34| 0: [Parameter] p0
|
|
# 34| 0: [TypeAccess] String
|
|
# 34| 1: [Parameter] p1
|
|
# 34| 0: [TypeAccess] String
|
|
# 34| 2: [Parameter] p2
|
|
# 34| 0: [TypeAccess] String
|
|
# 34| 3: [Parameter] p3
|
|
# 34| 0: [TypeAccess] int
|
|
# 34| 4: [Parameter] p4
|
|
# 34| 0: [TypeAccess] Object
|
|
# 34| 5: [BlockStmt] { ... }
|
|
# 34| 0: [IfStmt] if (...)
|
|
# 34| 0: [EQExpr] ... == ...
|
|
# 34| 0: [AndBitwiseExpr] ... & ...
|
|
# 34| 0: [IntegerLiteral] 2
|
|
# 34| 1: [VarAccess] p3
|
|
# 34| 1: [IntegerLiteral] 0
|
|
# 34| 1: [ExprStmt] <Expr>;
|
|
# 34| 0: [AssignExpr] ...=...
|
|
# 34| 0: [VarAccess] p1
|
|
# 34| 1: [VarAccess] p0
|
|
# 34| 1: [IfStmt] if (...)
|
|
# 34| 0: [EQExpr] ... == ...
|
|
# 34| 0: [AndBitwiseExpr] ... & ...
|
|
# 34| 0: [IntegerLiteral] 4
|
|
# 34| 1: [VarAccess] p3
|
|
# 34| 1: [IntegerLiteral] 0
|
|
# 34| 1: [ExprStmt] <Expr>;
|
|
# 34| 0: [AssignExpr] ...=...
|
|
# 34| 0: [VarAccess] p2
|
|
# 34| 1: [StringLiteral] "hello world"
|
|
# 34| 2: [ReturnStmt] return ...
|
|
# 34| 0: [MethodCall] f(...)
|
|
# 34| -1: [TypeAccess] TestStaticMember
|
|
# 34| 0: [VarAccess] p0
|
|
# 34| 1: [VarAccess] p1
|
|
# 34| 2: [VarAccess] p2
|
|
# 38| 4: [Method] user
|
|
# 38| 3: [TypeAccess] Unit
|
|
# 38| 5: [BlockStmt] { ... }
|
|
# 39| 0: [ExprStmt] <Expr>;
|
|
# 39| 0: [MethodCall] f$default(...)
|
|
# 39| -1: [TypeAccess] TestStaticMember
|
|
# 39| 0: [StringLiteral] "static sunk"
|
|
# 1| 1: [NullLiteral] null
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 1
|
|
# 1| 4: [NullLiteral] null
|
|
# 40| 1: [ExprStmt] <Expr>;
|
|
# 40| 0: [MethodCall] f$default(...)
|
|
# 40| -1: [TypeAccess] TestStaticMember
|
|
# 40| 0: [StringLiteral] "static sunk fp"
|
|
# 40| 1: [StringLiteral] "static sunk 2"
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 3
|
|
# 1| 4: [NullLiteral] null
|
|
# 41| 2: [ExprStmt] <Expr>;
|
|
# 41| 0: [MethodCall] f(...)
|
|
# 41| -1: [TypeAccess] TestStaticMember
|
|
# 41| 0: [StringLiteral] "not sunk"
|
|
# 41| 1: [StringLiteral] "static sunk 3"
|
|
# 41| 2: [StringLiteral] "not sunk"
|
|
# 46| 5: [Class] ExtendMe
|
|
# 46| 1: [Constructor] ExtendMe
|
|
# 46| 5: [BlockStmt] { ... }
|
|
# 46| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 46| 1: [BlockStmt] { ... }
|
|
# 48| 2: [Method] f
|
|
# 48| 3: [TypeAccess] String
|
|
#-----| 4: (Parameters)
|
|
# 48| 0: [Parameter] x
|
|
# 48| 0: [TypeAccess] String
|
|
# 48| 5: [BlockStmt] { ... }
|
|
# 48| 0: [ReturnStmt] return ...
|
|
# 48| 0: [VarAccess] x
|
|
# 52| 6: [Class] TestReceiverReferences
|
|
# 52| 1: [Constructor] TestReceiverReferences
|
|
# 52| 5: [BlockStmt] { ... }
|
|
# 52| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 52| 1: [BlockStmt] { ... }
|
|
# 54| 2: [Method] g
|
|
# 54| 3: [TypeAccess] String
|
|
#-----| 4: (Parameters)
|
|
# 54| 0: [Parameter] x
|
|
# 54| 0: [TypeAccess] String
|
|
# 54| 5: [BlockStmt] { ... }
|
|
# 54| 0: [ReturnStmt] return ...
|
|
# 54| 0: [VarAccess] x
|
|
# 56| 3: [ExtensionMethod] test
|
|
# 56| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 56| 0: [Parameter] <this>
|
|
# 56| 0: [TypeAccess] ExtendMe
|
|
# 56| 1: [Parameter] x
|
|
# 56| 0: [TypeAccess] String
|
|
# 56| 2: [Parameter] y
|
|
# 56| 0: [TypeAccess] String
|
|
# 56| 3: [Parameter] z
|
|
# 56| 0: [TypeAccess] String
|
|
# 56| 5: [BlockStmt] { ... }
|
|
# 57| 0: [ExprStmt] <Expr>;
|
|
# 57| 0: [MethodCall] sink(...)
|
|
# 57| -1: [TypeAccess] TestKt
|
|
# 57| 0: [VarAccess] y
|
|
# 56| 4: [ExtensionMethod] test$default
|
|
# 56| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 56| 0: [Parameter] p0
|
|
# 56| 0: [TypeAccess] TestReceiverReferences
|
|
# 56| 1: [Parameter] p1
|
|
# 56| 0: [TypeAccess] ExtendMe
|
|
# 56| 2: [Parameter] p2
|
|
# 56| 0: [TypeAccess] String
|
|
# 56| 3: [Parameter] p3
|
|
# 56| 0: [TypeAccess] String
|
|
# 56| 4: [Parameter] p4
|
|
# 56| 0: [TypeAccess] String
|
|
# 56| 5: [Parameter] p5
|
|
# 56| 0: [TypeAccess] int
|
|
# 56| 6: [Parameter] p6
|
|
# 56| 0: [TypeAccess] Object
|
|
# 56| 5: [BlockStmt] { ... }
|
|
# 56| 0: [IfStmt] if (...)
|
|
# 56| 0: [EQExpr] ... == ...
|
|
# 56| 0: [AndBitwiseExpr] ... & ...
|
|
# 56| 0: [IntegerLiteral] 2
|
|
# 56| 1: [VarAccess] p5
|
|
# 56| 1: [IntegerLiteral] 0
|
|
# 56| 1: [ExprStmt] <Expr>;
|
|
# 56| 0: [AssignExpr] ...=...
|
|
# 56| 0: [VarAccess] p3
|
|
# 56| 1: [MethodCall] f(...)
|
|
# 56| -1: [VarAccess] p0
|
|
# 56| 0: [MethodCall] g(...)
|
|
# 56| -1: [VarAccess] p0
|
|
# 56| 0: [VarAccess] p2
|
|
# 56| 1: [IfStmt] if (...)
|
|
# 56| 0: [EQExpr] ... == ...
|
|
# 56| 0: [AndBitwiseExpr] ... & ...
|
|
# 56| 0: [IntegerLiteral] 4
|
|
# 56| 1: [VarAccess] p5
|
|
# 56| 1: [IntegerLiteral] 0
|
|
# 56| 1: [ExprStmt] <Expr>;
|
|
# 56| 0: [AssignExpr] ...=...
|
|
# 56| 0: [VarAccess] p4
|
|
# 56| 1: [StringLiteral] "hello world"
|
|
# 56| 2: [ReturnStmt] return ...
|
|
# 56| 0: [MethodCall] test(...)
|
|
# 56| -1: [VarAccess] p0
|
|
# 56| 0: [ExtensionReceiverAccess] this
|
|
# 56| 1: [VarAccess] p2
|
|
# 56| 2: [VarAccess] p3
|
|
# 56| 3: [VarAccess] p4
|
|
# 60| 5: [Method] user
|
|
# 60| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 60| 0: [Parameter] t
|
|
# 60| 0: [TypeAccess] ExtendMe
|
|
# 60| 5: [BlockStmt] { ... }
|
|
# 61| 0: [ExprStmt] <Expr>;
|
|
# 61| 0: [MethodCall] test$default(...)
|
|
# 61| -1: [TypeAccess] TestReceiverReferences
|
|
# 61| 0: [ThisAccess] this
|
|
# 61| 1: [VarAccess] t
|
|
# 61| 2: [StringLiteral] "receiver refs sunk"
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [NullLiteral] null
|
|
# 1| 5: [IntegerLiteral] 1
|
|
# 1| 6: [NullLiteral] null
|
|
# 62| 1: [ExprStmt] <Expr>;
|
|
# 62| 0: [MethodCall] test$default(...)
|
|
# 62| -1: [TypeAccess] TestReceiverReferences
|
|
# 62| 0: [ThisAccess] this
|
|
# 62| 1: [VarAccess] t
|
|
# 62| 2: [StringLiteral] "receiver refs sunk fp"
|
|
# 62| 3: [StringLiteral] "receiver refs sunk 2"
|
|
# 1| 4: [NullLiteral] null
|
|
# 1| 5: [IntegerLiteral] 3
|
|
# 1| 6: [NullLiteral] null
|
|
# 63| 2: [ExprStmt] <Expr>;
|
|
# 63| 0: [MethodCall] test(...)
|
|
# 63| -1: [ThisAccess] this
|
|
# 63| 0: [VarAccess] t
|
|
# 63| 1: [StringLiteral] "not sunk"
|
|
# 63| 2: [StringLiteral] "receiver refs sunk 3"
|
|
# 63| 3: [StringLiteral] "not sunk"
|
|
# 68| 7: [Class] TestConstructor
|
|
# 68| 1: [Constructor] TestConstructor
|
|
#-----| 4: (Parameters)
|
|
# 68| 0: [Parameter] x
|
|
# 68| 0: [TypeAccess] String
|
|
# 68| 1: [Parameter] y
|
|
# 68| 0: [TypeAccess] String
|
|
# 68| 2: [Parameter] z
|
|
# 68| 0: [TypeAccess] String
|
|
# 68| 5: [BlockStmt] { ... }
|
|
# 68| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 68| 1: [BlockStmt] { ... }
|
|
# 71| 0: [ExprStmt] <Expr>;
|
|
# 71| 0: [MethodCall] sink(...)
|
|
# 71| -1: [TypeAccess] TestKt
|
|
# 71| 0: [VarAccess] y
|
|
# 68| 2: [Constructor] TestConstructor
|
|
#-----| 4: (Parameters)
|
|
# 68| 0: [Parameter] p0
|
|
# 68| 0: [TypeAccess] String
|
|
# 68| 1: [Parameter] p1
|
|
# 68| 0: [TypeAccess] String
|
|
# 68| 2: [Parameter] p2
|
|
# 68| 0: [TypeAccess] String
|
|
# 68| 3: [Parameter] p3
|
|
# 68| 0: [TypeAccess] int
|
|
# 68| 4: [Parameter] p4
|
|
# 68| 0: [TypeAccess] DefaultConstructorMarker
|
|
# 68| 5: [BlockStmt] { ... }
|
|
# 68| 0: [IfStmt] if (...)
|
|
# 68| 0: [EQExpr] ... == ...
|
|
# 68| 0: [AndBitwiseExpr] ... & ...
|
|
# 68| 0: [IntegerLiteral] 2
|
|
# 68| 1: [VarAccess] p3
|
|
# 68| 1: [IntegerLiteral] 0
|
|
# 68| 1: [ExprStmt] <Expr>;
|
|
# 68| 0: [AssignExpr] ...=...
|
|
# 68| 0: [VarAccess] p1
|
|
# 68| 1: [VarAccess] p0
|
|
# 68| 1: [IfStmt] if (...)
|
|
# 68| 0: [EQExpr] ... == ...
|
|
# 68| 0: [AndBitwiseExpr] ... & ...
|
|
# 68| 0: [IntegerLiteral] 4
|
|
# 68| 1: [VarAccess] p3
|
|
# 68| 1: [IntegerLiteral] 0
|
|
# 68| 1: [ExprStmt] <Expr>;
|
|
# 68| 0: [AssignExpr] ...=...
|
|
# 68| 0: [VarAccess] p2
|
|
# 68| 1: [StringLiteral] "hello world"
|
|
# 68| 2: [ThisConstructorInvocationStmt] this(...)
|
|
# 68| 0: [VarAccess] p0
|
|
# 68| 1: [VarAccess] p1
|
|
# 68| 2: [VarAccess] p2
|
|
# 74| 3: [Method] user
|
|
# 74| 3: [TypeAccess] Unit
|
|
# 74| 5: [BlockStmt] { ... }
|
|
# 75| 0: [ExprStmt] <Expr>;
|
|
# 75| 0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
|
|
# 75| 0: [TypeAccess] Unit
|
|
# 75| 1: [ClassInstanceExpr] new TestConstructor(...)
|
|
# 75| -3: [TypeAccess] TestConstructor
|
|
# 75| 0: [StringLiteral] "constructor sunk"
|
|
# 1| 1: [NullLiteral] null
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 1
|
|
# 1| 4: [NullLiteral] null
|
|
# 76| 1: [ExprStmt] <Expr>;
|
|
# 76| 0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
|
|
# 76| 0: [TypeAccess] Unit
|
|
# 76| 1: [ClassInstanceExpr] new TestConstructor(...)
|
|
# 76| -3: [TypeAccess] TestConstructor
|
|
# 76| 0: [StringLiteral] "constructor sunk fp"
|
|
# 76| 1: [StringLiteral] "constructor sunk 2"
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 3
|
|
# 1| 4: [NullLiteral] null
|
|
# 77| 2: [ExprStmt] <Expr>;
|
|
# 77| 0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
|
|
# 77| 0: [TypeAccess] Unit
|
|
# 77| 1: [ClassInstanceExpr] new TestConstructor(...)
|
|
# 77| -3: [TypeAccess] TestConstructor
|
|
# 77| 0: [StringLiteral] "not sunk"
|
|
# 77| 1: [StringLiteral] "constructor sunk 3"
|
|
# 77| 2: [StringLiteral] "not sunk"
|
|
# 82| 8: [Class] TestLocal
|
|
# 82| 1: [Constructor] TestLocal
|
|
# 82| 5: [BlockStmt] { ... }
|
|
# 82| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 82| 1: [BlockStmt] { ... }
|
|
# 84| 2: [Method] enclosing
|
|
# 84| 3: [TypeAccess] Unit
|
|
# 84| 5: [BlockStmt] { ... }
|
|
# 86| 0: [LocalTypeDeclStmt] class ...
|
|
# 86| 0: [LocalClass]
|
|
# 86| 1: [Constructor]
|
|
# 86| 5: [BlockStmt] { ... }
|
|
# 86| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 86| 2: [Method] f
|
|
# 86| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 86| 0: [Parameter] x
|
|
# 86| 0: [TypeAccess] String
|
|
# 86| 1: [Parameter] y
|
|
# 86| 0: [TypeAccess] String
|
|
# 86| 2: [Parameter] z
|
|
# 86| 0: [TypeAccess] String
|
|
# 86| 5: [BlockStmt] { ... }
|
|
# 87| 0: [ExprStmt] <Expr>;
|
|
# 87| 0: [MethodCall] sink(...)
|
|
# 87| -1: [TypeAccess] TestKt
|
|
# 87| 0: [VarAccess] y
|
|
# 86| 3: [Method] f$default
|
|
# 86| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 86| 0: [Parameter] p0
|
|
# 86| 0: [TypeAccess] String
|
|
# 86| 1: [Parameter] p1
|
|
# 86| 0: [TypeAccess] String
|
|
# 86| 2: [Parameter] p2
|
|
# 86| 0: [TypeAccess] String
|
|
# 86| 3: [Parameter] p3
|
|
# 86| 0: [TypeAccess] int
|
|
# 86| 4: [Parameter] p4
|
|
# 86| 0: [TypeAccess] Object
|
|
# 86| 5: [BlockStmt] { ... }
|
|
# 86| 0: [IfStmt] if (...)
|
|
# 86| 0: [EQExpr] ... == ...
|
|
# 86| 0: [AndBitwiseExpr] ... & ...
|
|
# 86| 0: [IntegerLiteral] 2
|
|
# 86| 1: [VarAccess] p3
|
|
# 86| 1: [IntegerLiteral] 0
|
|
# 86| 1: [ExprStmt] <Expr>;
|
|
# 86| 0: [AssignExpr] ...=...
|
|
# 86| 0: [VarAccess] p1
|
|
# 86| 1: [VarAccess] p0
|
|
# 86| 1: [IfStmt] if (...)
|
|
# 86| 0: [EQExpr] ... == ...
|
|
# 86| 0: [AndBitwiseExpr] ... & ...
|
|
# 86| 0: [IntegerLiteral] 4
|
|
# 86| 1: [VarAccess] p3
|
|
# 86| 1: [IntegerLiteral] 0
|
|
# 86| 1: [ExprStmt] <Expr>;
|
|
# 86| 0: [AssignExpr] ...=...
|
|
# 86| 0: [VarAccess] p2
|
|
# 86| 1: [StringLiteral] "hello world"
|
|
# 86| 2: [ReturnStmt] return ...
|
|
# 86| 0: [MethodCall] f(...)
|
|
# 86| -1: [ClassInstanceExpr] new (...)
|
|
# 86| -3: [TypeAccess] Object
|
|
# 86| 0: [VarAccess] p0
|
|
# 86| 1: [VarAccess] p1
|
|
# 86| 2: [VarAccess] p2
|
|
# 90| 1: [LocalTypeDeclStmt] class ...
|
|
# 90| 0: [LocalClass]
|
|
# 90| 1: [Constructor]
|
|
# 90| 5: [BlockStmt] { ... }
|
|
# 90| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 90| 2: [Method] user
|
|
# 90| 3: [TypeAccess] Unit
|
|
# 90| 5: [BlockStmt] { ... }
|
|
# 91| 0: [ExprStmt] <Expr>;
|
|
# 91| 0: [MethodCall] f$default(...)
|
|
# 91| -1: [TypeAccess]
|
|
# 91| 0: [StringLiteral] "local sunk"
|
|
# 1| 1: [NullLiteral] null
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 1
|
|
# 1| 4: [NullLiteral] null
|
|
# 92| 1: [ExprStmt] <Expr>;
|
|
# 92| 0: [MethodCall] f$default(...)
|
|
# 92| -1: [TypeAccess]
|
|
# 92| 0: [StringLiteral] "local sunk fp"
|
|
# 92| 1: [StringLiteral] "local sunk 2"
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 3
|
|
# 1| 4: [NullLiteral] null
|
|
# 93| 2: [ExprStmt] <Expr>;
|
|
# 93| 0: [MethodCall] f(...)
|
|
# 93| -1: [ClassInstanceExpr] new (...)
|
|
# 93| -3: [TypeAccess] Object
|
|
# 93| 0: [StringLiteral] "not sunk"
|
|
# 93| 1: [StringLiteral] "local sunk 3"
|
|
# 93| 2: [StringLiteral] "not sunk"
|
|
# 100| 9: [Class] TestLocalClass
|
|
# 100| 1: [Constructor] TestLocalClass
|
|
# 100| 5: [BlockStmt] { ... }
|
|
# 100| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 100| 1: [BlockStmt] { ... }
|
|
# 102| 2: [Method] enclosingFunction
|
|
# 102| 3: [TypeAccess] Unit
|
|
# 102| 5: [BlockStmt] { ... }
|
|
# 104| 0: [LocalTypeDeclStmt] class ...
|
|
# 104| 0: [LocalClass] EnclosingLocalClass
|
|
# 104| 1: [Constructor] EnclosingLocalClass
|
|
# 104| 5: [BlockStmt] { ... }
|
|
# 104| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 104| 1: [BlockStmt] { ... }
|
|
# 106| 2: [Method] f
|
|
# 106| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 106| 0: [Parameter] x
|
|
# 106| 0: [TypeAccess] String
|
|
# 106| 1: [Parameter] y
|
|
# 106| 0: [TypeAccess] String
|
|
# 106| 2: [Parameter] z
|
|
# 106| 0: [TypeAccess] String
|
|
# 106| 5: [BlockStmt] { ... }
|
|
# 107| 0: [ExprStmt] <Expr>;
|
|
# 107| 0: [MethodCall] sink(...)
|
|
# 107| -1: [TypeAccess] TestKt
|
|
# 107| 0: [VarAccess] y
|
|
# 106| 3: [Method] f$default
|
|
# 106| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 106| 0: [Parameter] p0
|
|
# 106| 0: [TypeAccess] EnclosingLocalClass
|
|
# 106| 1: [Parameter] p1
|
|
# 106| 0: [TypeAccess] String
|
|
# 106| 2: [Parameter] p2
|
|
# 106| 0: [TypeAccess] String
|
|
# 106| 3: [Parameter] p3
|
|
# 106| 0: [TypeAccess] String
|
|
# 106| 4: [Parameter] p4
|
|
# 106| 0: [TypeAccess] int
|
|
# 106| 5: [Parameter] p5
|
|
# 106| 0: [TypeAccess] Object
|
|
# 106| 5: [BlockStmt] { ... }
|
|
# 106| 0: [IfStmt] if (...)
|
|
# 106| 0: [EQExpr] ... == ...
|
|
# 106| 0: [AndBitwiseExpr] ... & ...
|
|
# 106| 0: [IntegerLiteral] 2
|
|
# 106| 1: [VarAccess] p4
|
|
# 106| 1: [IntegerLiteral] 0
|
|
# 106| 1: [ExprStmt] <Expr>;
|
|
# 106| 0: [AssignExpr] ...=...
|
|
# 106| 0: [VarAccess] p2
|
|
# 106| 1: [VarAccess] p1
|
|
# 106| 1: [IfStmt] if (...)
|
|
# 106| 0: [EQExpr] ... == ...
|
|
# 106| 0: [AndBitwiseExpr] ... & ...
|
|
# 106| 0: [IntegerLiteral] 4
|
|
# 106| 1: [VarAccess] p4
|
|
# 106| 1: [IntegerLiteral] 0
|
|
# 106| 1: [ExprStmt] <Expr>;
|
|
# 106| 0: [AssignExpr] ...=...
|
|
# 106| 0: [VarAccess] p3
|
|
# 106| 1: [StringLiteral] "hello world"
|
|
# 106| 2: [ReturnStmt] return ...
|
|
# 106| 0: [MethodCall] f(...)
|
|
# 106| -1: [VarAccess] p0
|
|
# 106| 0: [VarAccess] p1
|
|
# 106| 1: [VarAccess] p2
|
|
# 106| 2: [VarAccess] p3
|
|
# 110| 4: [Method] user
|
|
# 110| 3: [TypeAccess] Unit
|
|
# 110| 5: [BlockStmt] { ... }
|
|
# 111| 0: [ExprStmt] <Expr>;
|
|
# 111| 0: [MethodCall] f$default(...)
|
|
# 111| -1: [TypeAccess] EnclosingLocalClass
|
|
# 111| 0: [ThisAccess] this
|
|
# 111| 1: [StringLiteral] "local sunk"
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [IntegerLiteral] 1
|
|
# 1| 5: [NullLiteral] null
|
|
# 112| 1: [ExprStmt] <Expr>;
|
|
# 112| 0: [MethodCall] f$default(...)
|
|
# 112| -1: [TypeAccess] EnclosingLocalClass
|
|
# 112| 0: [ThisAccess] this
|
|
# 112| 1: [StringLiteral] "local sunk fp"
|
|
# 112| 2: [StringLiteral] "local sunk 2"
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [IntegerLiteral] 3
|
|
# 1| 5: [NullLiteral] null
|
|
# 113| 2: [ExprStmt] <Expr>;
|
|
# 113| 0: [MethodCall] f(...)
|
|
# 113| -1: [ThisAccess] this
|
|
# 113| 0: [StringLiteral] "not sunk"
|
|
# 113| 1: [StringLiteral] "local sunk 3"
|
|
# 113| 2: [StringLiteral] "not sunk"
|
|
# 122| 10: [Class,GenericType,ParameterizedType] TestGeneric
|
|
#-----| -2: (Generic Parameters)
|
|
# 122| 0: [TypeVariable] T
|
|
# 122| 1: [Constructor] TestGeneric
|
|
# 122| 5: [BlockStmt] { ... }
|
|
# 122| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 122| 1: [BlockStmt] { ... }
|
|
# 124| 2: [Method] f
|
|
# 124| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 124| 0: [Parameter] x
|
|
# 124| 0: [TypeAccess] T
|
|
# 124| 1: [Parameter] y
|
|
# 124| 0: [TypeAccess] T
|
|
# 124| 2: [Parameter] z
|
|
# 124| 0: [TypeAccess] T
|
|
# 124| 5: [BlockStmt] { ... }
|
|
# 125| 0: [ExprStmt] <Expr>;
|
|
# 125| 0: [MethodCall] sink(...)
|
|
# 125| -1: [TypeAccess] TestKt
|
|
# 125| 0: [VarAccess] y
|
|
# 124| 3: [Method] f$default
|
|
# 124| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 124| 0: [Parameter] p0
|
|
# 124| 0: [TypeAccess] TestGeneric<>
|
|
# 124| 1: [Parameter] p1
|
|
# 124| 0: [TypeAccess] Object
|
|
# 124| 2: [Parameter] p2
|
|
# 124| 0: [TypeAccess] Object
|
|
# 124| 3: [Parameter] p3
|
|
# 124| 0: [TypeAccess] Object
|
|
# 124| 4: [Parameter] p4
|
|
# 124| 0: [TypeAccess] int
|
|
# 124| 5: [Parameter] p5
|
|
# 124| 0: [TypeAccess] Object
|
|
# 124| 5: [BlockStmt] { ... }
|
|
# 124| 0: [IfStmt] if (...)
|
|
# 124| 0: [EQExpr] ... == ...
|
|
# 124| 0: [AndBitwiseExpr] ... & ...
|
|
# 124| 0: [IntegerLiteral] 2
|
|
# 124| 1: [VarAccess] p4
|
|
# 124| 1: [IntegerLiteral] 0
|
|
# 124| 1: [ExprStmt] <Expr>;
|
|
# 124| 0: [AssignExpr] ...=...
|
|
# 124| 0: [VarAccess] p2
|
|
# 124| 1: [VarAccess] p1
|
|
# 124| 1: [IfStmt] if (...)
|
|
# 124| 0: [EQExpr] ... == ...
|
|
# 124| 0: [AndBitwiseExpr] ... & ...
|
|
# 124| 0: [IntegerLiteral] 4
|
|
# 124| 1: [VarAccess] p4
|
|
# 124| 1: [IntegerLiteral] 0
|
|
# 124| 1: [ExprStmt] <Expr>;
|
|
# 124| 0: [AssignExpr] ...=...
|
|
# 124| 0: [VarAccess] p3
|
|
# 124| 1: [NullLiteral] null
|
|
# 124| 2: [ReturnStmt] return ...
|
|
# 124| 0: [MethodCall] f(...)
|
|
# 124| -1: [VarAccess] p0
|
|
# 124| 0: [VarAccess] p1
|
|
# 124| 1: [VarAccess] p2
|
|
# 124| 2: [VarAccess] p3
|
|
# 128| 4: [Method] user
|
|
# 128| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 128| 0: [Parameter] tgs
|
|
# 128| 0: [TypeAccess] TestGeneric<String>
|
|
# 128| 0: [TypeAccess] String
|
|
# 128| 1: [Parameter] tcs
|
|
# 128| 0: [TypeAccess] TestGeneric<CharSequence>
|
|
# 128| 0: [TypeAccess] CharSequence
|
|
# 128| 5: [BlockStmt] { ... }
|
|
# 129| 0: [ExprStmt] <Expr>;
|
|
# 129| 0: [MethodCall] f$default(...)
|
|
# 129| -1: [TypeAccess] TestGeneric<>
|
|
# 129| 0: [VarAccess] tgs
|
|
# 129| 1: [StringLiteral] "generic sunk"
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [IntegerLiteral] 1
|
|
# 1| 5: [NullLiteral] null
|
|
# 130| 1: [ExprStmt] <Expr>;
|
|
# 130| 0: [MethodCall] f$default(...)
|
|
# 130| -1: [TypeAccess] TestGeneric<>
|
|
# 130| 0: [VarAccess] tcs
|
|
# 130| 1: [StringLiteral] "generic sunk fp"
|
|
# 130| 2: [StringLiteral] "generic sunk 2"
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [IntegerLiteral] 3
|
|
# 1| 5: [NullLiteral] null
|
|
# 131| 2: [ExprStmt] <Expr>;
|
|
# 131| 0: [MethodCall] f(...)
|
|
# 131| -1: [VarAccess] tgs
|
|
# 131| 0: [StringLiteral] "not sunk"
|
|
# 131| 1: [StringLiteral] "generic sunk 3"
|
|
# 131| 2: [StringLiteral] "not sunk"
|
|
# 132| 3: [ExprStmt] <Expr>;
|
|
# 132| 0: [MethodCall] f(...)
|
|
# 132| -1: [VarAccess] tcs
|
|
# 132| 0: [StringLiteral] "not sunk"
|
|
# 132| 1: [StringLiteral] "generic sunk 3"
|
|
# 132| 2: [StringLiteral] "not sunk"
|
|
# 135| 5: [Method] testReturn
|
|
# 135| 3: [TypeAccess] T
|
|
#-----| 4: (Parameters)
|
|
# 135| 0: [Parameter] t1
|
|
# 135| 0: [TypeAccess] T
|
|
# 135| 1: [Parameter] t2
|
|
# 135| 0: [TypeAccess] T
|
|
# 135| 5: [BlockStmt] { ... }
|
|
# 135| 0: [ReturnStmt] return ...
|
|
# 135| 0: [VarAccess] t1
|
|
# 135| 6: [Method] testReturn$default
|
|
# 135| 3: [TypeAccess] Object
|
|
#-----| 4: (Parameters)
|
|
# 135| 0: [Parameter] p0
|
|
# 135| 0: [TypeAccess] TestGeneric<>
|
|
# 135| 1: [Parameter] p1
|
|
# 135| 0: [TypeAccess] Object
|
|
# 135| 2: [Parameter] p2
|
|
# 135| 0: [TypeAccess] Object
|
|
# 135| 3: [Parameter] p3
|
|
# 135| 0: [TypeAccess] int
|
|
# 135| 4: [Parameter] p4
|
|
# 135| 0: [TypeAccess] Object
|
|
# 135| 5: [BlockStmt] { ... }
|
|
# 135| 0: [IfStmt] if (...)
|
|
# 135| 0: [EQExpr] ... == ...
|
|
# 135| 0: [AndBitwiseExpr] ... & ...
|
|
# 135| 0: [IntegerLiteral] 2
|
|
# 135| 1: [VarAccess] p3
|
|
# 135| 1: [IntegerLiteral] 0
|
|
# 135| 1: [ExprStmt] <Expr>;
|
|
# 135| 0: [AssignExpr] ...=...
|
|
# 135| 0: [VarAccess] p2
|
|
# 135| 1: [NullLiteral] null
|
|
# 135| 1: [ReturnStmt] return ...
|
|
# 135| 0: [MethodCall] testReturn(...)
|
|
# 135| -1: [VarAccess] p0
|
|
# 135| 0: [VarAccess] p1
|
|
# 135| 1: [VarAccess] p2
|
|
# 137| 7: [Method] testReturnUser
|
|
# 137| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 137| 0: [Parameter] tgs
|
|
# 137| 0: [TypeAccess] TestGeneric<String>
|
|
# 137| 0: [TypeAccess] String
|
|
# 137| 5: [BlockStmt] { ... }
|
|
# 138| 0: [ExprStmt] <Expr>;
|
|
# 138| 0: [MethodCall] sink(...)
|
|
# 138| -1: [TypeAccess] TestKt
|
|
# 138| 0: [MethodCall] testReturn$default(...)
|
|
# 138| -1: [TypeAccess] TestGeneric<>
|
|
# 138| 0: [VarAccess] tgs
|
|
# 138| 1: [StringLiteral] "sunk return value"
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [IntegerLiteral] 1
|
|
# 1| 4: [NullLiteral] null
|
|
# 143| 12: [Class,GenericType,ParameterizedType] TestGenericFunction
|
|
#-----| -2: (Generic Parameters)
|
|
# 143| 0: [TypeVariable] T
|
|
# 143| 1: [Constructor] TestGenericFunction
|
|
# 143| 5: [BlockStmt] { ... }
|
|
# 143| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 143| 1: [BlockStmt] { ... }
|
|
# 145| 2: [Method] f
|
|
#-----| 2: (Generic Parameters)
|
|
# 145| 0: [TypeVariable] S
|
|
# 145| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 145| 0: [Parameter] x
|
|
# 145| 0: [TypeAccess] S
|
|
# 145| 1: [Parameter] y
|
|
# 145| 0: [TypeAccess] T
|
|
# 145| 2: [Parameter] def1
|
|
# 145| 0: [TypeAccess] T
|
|
# 145| 3: [Parameter] def2
|
|
# 145| 0: [TypeAccess] List<? extends T>
|
|
# 145| 0: [WildcardTypeAccess] ? ...
|
|
# 145| 0: [TypeAccess] T
|
|
# 145| 4: [Parameter] def3
|
|
# 145| 0: [TypeAccess] S
|
|
# 145| 5: [Parameter] def4
|
|
# 145| 0: [TypeAccess] List<? extends S>
|
|
# 145| 0: [WildcardTypeAccess] ? ...
|
|
# 145| 0: [TypeAccess] S
|
|
# 145| 5: [BlockStmt] { ... }
|
|
# 146| 0: [ExprStmt] <Expr>;
|
|
# 146| 0: [MethodCall] sink(...)
|
|
# 146| -1: [TypeAccess] TestKt
|
|
# 146| 0: [VarAccess] y
|
|
# 145| 3: [Method] f$default
|
|
# 145| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 145| 0: [Parameter] p0
|
|
# 145| 0: [TypeAccess] TestGenericFunction<>
|
|
# 145| 1: [Parameter] p1
|
|
# 145| 0: [TypeAccess] Object
|
|
# 145| 2: [Parameter] p2
|
|
# 145| 0: [TypeAccess] Object
|
|
# 145| 3: [Parameter] p3
|
|
# 145| 0: [TypeAccess] Object
|
|
# 145| 4: [Parameter] p4
|
|
# 145| 0: [TypeAccess] List<>
|
|
# 145| 5: [Parameter] p5
|
|
# 145| 0: [TypeAccess] Object
|
|
# 145| 6: [Parameter] p6
|
|
# 145| 0: [TypeAccess] List<>
|
|
# 145| 7: [Parameter] p7
|
|
# 145| 0: [TypeAccess] int
|
|
# 145| 8: [Parameter] p8
|
|
# 145| 0: [TypeAccess] Object
|
|
# 145| 5: [BlockStmt] { ... }
|
|
# 145| 0: [IfStmt] if (...)
|
|
# 145| 0: [EQExpr] ... == ...
|
|
# 145| 0: [AndBitwiseExpr] ... & ...
|
|
# 145| 0: [IntegerLiteral] 2
|
|
# 145| 1: [VarAccess] p7
|
|
# 145| 1: [IntegerLiteral] 0
|
|
# 145| 1: [ExprStmt] <Expr>;
|
|
# 145| 0: [AssignExpr] ...=...
|
|
# 145| 0: [VarAccess] p2
|
|
# 145| 1: [VarAccess] p1
|
|
# 145| 1: [IfStmt] if (...)
|
|
# 145| 0: [EQExpr] ... == ...
|
|
# 145| 0: [AndBitwiseExpr] ... & ...
|
|
# 145| 0: [IntegerLiteral] 4
|
|
# 145| 1: [VarAccess] p7
|
|
# 145| 1: [IntegerLiteral] 0
|
|
# 145| 1: [ExprStmt] <Expr>;
|
|
# 145| 0: [AssignExpr] ...=...
|
|
# 145| 0: [VarAccess] p3
|
|
# 145| 1: [NullLiteral] null
|
|
# 145| 2: [IfStmt] if (...)
|
|
# 145| 0: [EQExpr] ... == ...
|
|
# 145| 0: [AndBitwiseExpr] ... & ...
|
|
# 145| 0: [IntegerLiteral] 8
|
|
# 145| 1: [VarAccess] p7
|
|
# 145| 1: [IntegerLiteral] 0
|
|
# 145| 1: [ExprStmt] <Expr>;
|
|
# 145| 0: [AssignExpr] ...=...
|
|
# 145| 0: [VarAccess] p4
|
|
# 145| 1: [MethodCall] listOf(...)
|
|
# 145| -2: [TypeAccess] T
|
|
# 145| -1: [TypeAccess] CollectionsKt
|
|
# 145| 0: [VarAccess] p2
|
|
# 145| 3: [IfStmt] if (...)
|
|
# 145| 0: [EQExpr] ... == ...
|
|
# 145| 0: [AndBitwiseExpr] ... & ...
|
|
# 145| 0: [IntegerLiteral] 16
|
|
# 145| 1: [VarAccess] p7
|
|
# 145| 1: [IntegerLiteral] 0
|
|
# 145| 1: [ExprStmt] <Expr>;
|
|
# 145| 0: [AssignExpr] ...=...
|
|
# 145| 0: [VarAccess] p5
|
|
# 145| 1: [NullLiteral] null
|
|
# 145| 4: [IfStmt] if (...)
|
|
# 145| 0: [EQExpr] ... == ...
|
|
# 145| 0: [AndBitwiseExpr] ... & ...
|
|
# 145| 0: [IntegerLiteral] 32
|
|
# 145| 1: [VarAccess] p7
|
|
# 145| 1: [IntegerLiteral] 0
|
|
# 145| 1: [ExprStmt] <Expr>;
|
|
# 145| 0: [AssignExpr] ...=...
|
|
# 145| 0: [VarAccess] p6
|
|
# 145| 1: [MethodCall] listOf(...)
|
|
# 145| -2: [TypeAccess] S
|
|
# 145| -1: [TypeAccess] CollectionsKt
|
|
# 145| 0: [VarAccess] p1
|
|
# 145| 5: [ReturnStmt] return ...
|
|
# 145| 0: [MethodCall] f(...)
|
|
# 145| -1: [VarAccess] p0
|
|
# 145| 0: [VarAccess] p1
|
|
# 145| 1: [VarAccess] p2
|
|
# 145| 2: [VarAccess] p3
|
|
# 145| 3: [VarAccess] p4
|
|
# 145| 4: [VarAccess] p5
|
|
# 145| 5: [VarAccess] p6
|
|
# 149| 4: [Method] user
|
|
# 149| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 149| 0: [Parameter] inst
|
|
# 149| 0: [TypeAccess] TestGenericFunction<String>
|
|
# 149| 0: [TypeAccess] String
|
|
# 149| 5: [BlockStmt] { ... }
|
|
# 150| 0: [ExprStmt] <Expr>;
|
|
# 150| 0: [MethodCall] f$default(...)
|
|
# 150| -1: [TypeAccess] TestGenericFunction<>
|
|
# 150| 0: [VarAccess] inst
|
|
# 150| 1: [StringLiteral] "generic function sunk"
|
|
# 1| 2: [NullLiteral] null
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [NullLiteral] null
|
|
# 1| 5: [NullLiteral] null
|
|
# 1| 6: [NullLiteral] null
|
|
# 1| 7: [IntegerLiteral] 1
|
|
# 1| 8: [NullLiteral] null
|
|
# 151| 1: [ExprStmt] <Expr>;
|
|
# 151| 0: [MethodCall] f$default(...)
|
|
# 151| -1: [TypeAccess] TestGenericFunction<>
|
|
# 151| 0: [VarAccess] inst
|
|
# 151| 1: [StringLiteral] "generic function sunk fp"
|
|
# 151| 2: [StringLiteral] "generic function sunk 2"
|
|
# 1| 3: [NullLiteral] null
|
|
# 1| 4: [NullLiteral] null
|
|
# 1| 5: [NullLiteral] null
|
|
# 1| 6: [NullLiteral] null
|
|
# 1| 7: [IntegerLiteral] 3
|
|
# 1| 8: [NullLiteral] null
|
|
# 156| 14: [Class] VisibilityTests
|
|
# 156| 1: [Constructor] VisibilityTests
|
|
# 156| 5: [BlockStmt] { ... }
|
|
# 156| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 156| 1: [BlockStmt] { ... }
|
|
# 158| 2: [Method] f
|
|
# 158| 3: [TypeAccess] int
|
|
#-----| 4: (Parameters)
|
|
# 158| 0: [Parameter] x
|
|
# 158| 0: [TypeAccess] int
|
|
# 158| 1: [Parameter] y
|
|
# 158| 0: [TypeAccess] int
|
|
# 158| 5: [BlockStmt] { ... }
|
|
# 158| 0: [ReturnStmt] return ...
|
|
# 158| 0: [AddExpr] ... + ...
|
|
# 158| 0: [VarAccess] x
|
|
# 158| 1: [VarAccess] y
|
|
# 158| 3: [Method] f$default
|
|
# 158| 3: [TypeAccess] int
|
|
#-----| 4: (Parameters)
|
|
# 158| 0: [Parameter] p0
|
|
# 158| 0: [TypeAccess] VisibilityTests
|
|
# 158| 1: [Parameter] p1
|
|
# 158| 0: [TypeAccess] int
|
|
# 158| 2: [Parameter] p2
|
|
# 158| 0: [TypeAccess] int
|
|
# 158| 3: [Parameter] p3
|
|
# 158| 0: [TypeAccess] int
|
|
# 158| 4: [Parameter] p4
|
|
# 158| 0: [TypeAccess] Object
|
|
# 158| 5: [BlockStmt] { ... }
|
|
# 158| 0: [IfStmt] if (...)
|
|
# 158| 0: [EQExpr] ... == ...
|
|
# 158| 0: [AndBitwiseExpr] ... & ...
|
|
# 158| 0: [IntegerLiteral] 2
|
|
# 158| 1: [VarAccess] p3
|
|
# 158| 1: [IntegerLiteral] 0
|
|
# 158| 1: [ExprStmt] <Expr>;
|
|
# 158| 0: [AssignExpr] ...=...
|
|
# 158| 0: [VarAccess] p2
|
|
# 158| 1: [IntegerLiteral] 0
|
|
# 158| 1: [ReturnStmt] return ...
|
|
# 158| 0: [MethodCall] f(...)
|
|
# 158| -1: [VarAccess] p0
|
|
# 158| 0: [VarAccess] p1
|
|
# 158| 1: [VarAccess] p2
|
|
# 159| 4: [Method] g$main
|
|
# 159| 3: [TypeAccess] int
|
|
#-----| 4: (Parameters)
|
|
# 159| 0: [Parameter] x
|
|
# 159| 0: [TypeAccess] int
|
|
# 159| 1: [Parameter] y
|
|
# 159| 0: [TypeAccess] int
|
|
# 159| 5: [BlockStmt] { ... }
|
|
# 159| 0: [ReturnStmt] return ...
|
|
# 159| 0: [AddExpr] ... + ...
|
|
# 159| 0: [VarAccess] x
|
|
# 159| 1: [VarAccess] y
|
|
# 159| 5: [Method] g$main$default
|
|
# 159| 3: [TypeAccess] int
|
|
#-----| 4: (Parameters)
|
|
# 159| 0: [Parameter] p0
|
|
# 159| 0: [TypeAccess] VisibilityTests
|
|
# 159| 1: [Parameter] p1
|
|
# 159| 0: [TypeAccess] int
|
|
# 159| 2: [Parameter] p2
|
|
# 159| 0: [TypeAccess] int
|
|
# 159| 3: [Parameter] p3
|
|
# 159| 0: [TypeAccess] int
|
|
# 159| 4: [Parameter] p4
|
|
# 159| 0: [TypeAccess] Object
|
|
# 159| 5: [BlockStmt] { ... }
|
|
# 159| 0: [IfStmt] if (...)
|
|
# 159| 0: [EQExpr] ... == ...
|
|
# 159| 0: [AndBitwiseExpr] ... & ...
|
|
# 159| 0: [IntegerLiteral] 2
|
|
# 159| 1: [VarAccess] p3
|
|
# 159| 1: [IntegerLiteral] 0
|
|
# 159| 1: [ExprStmt] <Expr>;
|
|
# 159| 0: [AssignExpr] ...=...
|
|
# 159| 0: [VarAccess] p2
|
|
# 159| 1: [IntegerLiteral] 0
|
|
# 159| 1: [ReturnStmt] return ...
|
|
# 159| 0: [MethodCall] g$main(...)
|
|
# 159| -1: [VarAccess] p0
|
|
# 159| 0: [VarAccess] p1
|
|
# 159| 1: [VarAccess] p2
|
|
# 160| 6: [Method] h
|
|
# 160| 3: [TypeAccess] int
|
|
#-----| 4: (Parameters)
|
|
# 160| 0: [Parameter] x
|
|
# 160| 0: [TypeAccess] int
|
|
# 160| 1: [Parameter] y
|
|
# 160| 0: [TypeAccess] int
|
|
# 160| 5: [BlockStmt] { ... }
|
|
# 160| 0: [ReturnStmt] return ...
|
|
# 160| 0: [AddExpr] ... + ...
|
|
# 160| 0: [VarAccess] x
|
|
# 160| 1: [VarAccess] y
|
|
# 160| 7: [Method] h$default
|
|
# 160| 3: [TypeAccess] int
|
|
#-----| 4: (Parameters)
|
|
# 160| 0: [Parameter] p0
|
|
# 160| 0: [TypeAccess] VisibilityTests
|
|
# 160| 1: [Parameter] p1
|
|
# 160| 0: [TypeAccess] int
|
|
# 160| 2: [Parameter] p2
|
|
# 160| 0: [TypeAccess] int
|
|
# 160| 3: [Parameter] p3
|
|
# 160| 0: [TypeAccess] int
|
|
# 160| 4: [Parameter] p4
|
|
# 160| 0: [TypeAccess] Object
|
|
# 160| 5: [BlockStmt] { ... }
|
|
# 160| 0: [IfStmt] if (...)
|
|
# 160| 0: [EQExpr] ... == ...
|
|
# 160| 0: [AndBitwiseExpr] ... & ...
|
|
# 160| 0: [IntegerLiteral] 2
|
|
# 160| 1: [VarAccess] p3
|
|
# 160| 1: [IntegerLiteral] 0
|
|
# 160| 1: [ExprStmt] <Expr>;
|
|
# 160| 0: [AssignExpr] ...=...
|
|
# 160| 0: [VarAccess] p2
|
|
# 160| 1: [IntegerLiteral] 0
|
|
# 160| 1: [ReturnStmt] return ...
|
|
# 160| 0: [MethodCall] h(...)
|
|
# 160| -1: [VarAccess] p0
|
|
# 160| 0: [VarAccess] p1
|
|
# 160| 1: [VarAccess] p2
|
|
# 161| 8: [Method] i
|
|
# 161| 3: [TypeAccess] int
|
|
#-----| 4: (Parameters)
|
|
# 161| 0: [Parameter] x
|
|
# 161| 0: [TypeAccess] int
|
|
# 161| 1: [Parameter] y
|
|
# 161| 0: [TypeAccess] int
|
|
# 161| 5: [BlockStmt] { ... }
|
|
# 161| 0: [ReturnStmt] return ...
|
|
# 161| 0: [AddExpr] ... + ...
|
|
# 161| 0: [VarAccess] x
|
|
# 161| 1: [VarAccess] y
|
|
# 161| 9: [Method] i$default
|
|
# 161| 3: [TypeAccess] int
|
|
#-----| 4: (Parameters)
|
|
# 161| 0: [Parameter] p0
|
|
# 161| 0: [TypeAccess] VisibilityTests
|
|
# 161| 1: [Parameter] p1
|
|
# 161| 0: [TypeAccess] int
|
|
# 161| 2: [Parameter] p2
|
|
# 161| 0: [TypeAccess] int
|
|
# 161| 3: [Parameter] p3
|
|
# 161| 0: [TypeAccess] int
|
|
# 161| 4: [Parameter] p4
|
|
# 161| 0: [TypeAccess] Object
|
|
# 161| 5: [BlockStmt] { ... }
|
|
# 161| 0: [IfStmt] if (...)
|
|
# 161| 0: [EQExpr] ... == ...
|
|
# 161| 0: [AndBitwiseExpr] ... & ...
|
|
# 161| 0: [IntegerLiteral] 2
|
|
# 161| 1: [VarAccess] p3
|
|
# 161| 1: [IntegerLiteral] 0
|
|
# 161| 1: [ExprStmt] <Expr>;
|
|
# 161| 0: [AssignExpr] ...=...
|
|
# 161| 0: [VarAccess] p2
|
|
# 161| 1: [IntegerLiteral] 0
|
|
# 161| 1: [ReturnStmt] return ...
|
|
# 161| 0: [MethodCall] i(...)
|
|
# 161| -1: [VarAccess] p0
|
|
# 161| 0: [VarAccess] p1
|
|
# 161| 1: [VarAccess] p2
|
|
# 165| 15: [Class,GenericType,ParameterizedType] TestGenericUsedWithinDefaultValue
|
|
#-----| -2: (Generic Parameters)
|
|
# 165| 0: [TypeVariable] T
|
|
# 165| 1: [Constructor] TestGenericUsedWithinDefaultValue
|
|
# 165| 5: [BlockStmt] { ... }
|
|
# 165| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 165| 1: [BlockStmt] { ... }
|
|
# 171| 2: [Method] f
|
|
# 171| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 171| 0: [Parameter] x
|
|
# 171| 0: [TypeAccess] int
|
|
# 171| 1: [Parameter] y
|
|
# 171| 0: [TypeAccess] String
|
|
# 171| 5: [BlockStmt] { ... }
|
|
# 171| 3: [Method] f$default
|
|
# 171| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 171| 0: [Parameter] p0
|
|
# 171| 0: [TypeAccess] TestGenericUsedWithinDefaultValue<>
|
|
# 171| 1: [Parameter] p1
|
|
# 171| 0: [TypeAccess] int
|
|
# 171| 2: [Parameter] p2
|
|
# 171| 0: [TypeAccess] String
|
|
# 171| 3: [Parameter] p3
|
|
# 171| 0: [TypeAccess] int
|
|
# 171| 4: [Parameter] p4
|
|
# 171| 0: [TypeAccess] Object
|
|
# 171| 5: [BlockStmt] { ... }
|
|
# 171| 0: [IfStmt] if (...)
|
|
# 171| 0: [EQExpr] ... == ...
|
|
# 171| 0: [AndBitwiseExpr] ... & ...
|
|
# 171| 0: [IntegerLiteral] 2
|
|
# 171| 1: [VarAccess] p3
|
|
# 171| 1: [IntegerLiteral] 0
|
|
# 171| 1: [ExprStmt] <Expr>;
|
|
# 171| 0: [AssignExpr] ...=...
|
|
# 171| 0: [VarAccess] p2
|
|
# 171| 1: [MethodCall] ident(...)
|
|
# 171| -1: [ClassInstanceExpr] new TestGenericUsedWithinDefaultValue<String>(...)
|
|
# 171| -3: [TypeAccess] TestGenericUsedWithinDefaultValue<String>
|
|
# 171| 0: [TypeAccess] String
|
|
# 171| 0: [StringLiteral] "Hello world"
|
|
# 171| 1: [ReturnStmt] return ...
|
|
# 171| 0: [MethodCall] f(...)
|
|
# 171| -1: [VarAccess] p0
|
|
# 171| 0: [VarAccess] p1
|
|
# 171| 1: [VarAccess] p2
|
|
# 173| 4: [Method] ident
|
|
# 173| 3: [TypeAccess] T
|
|
#-----| 4: (Parameters)
|
|
# 173| 0: [Parameter] t
|
|
# 173| 0: [TypeAccess] T
|
|
# 173| 5: [BlockStmt] { ... }
|
|
# 173| 0: [ReturnStmt] return ...
|
|
# 173| 0: [VarAccess] t
|
|
# 177| 17: [Class] TestOverloadsWithDefaults
|
|
# 177| 1: [Constructor] TestOverloadsWithDefaults
|
|
# 177| 5: [BlockStmt] { ... }
|
|
# 177| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 177| 1: [BlockStmt] { ... }
|
|
# 179| 2: [Method] f
|
|
# 179| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 179| 0: [Parameter] x
|
|
# 179| 0: [TypeAccess] int
|
|
# 179| 1: [Parameter] y
|
|
# 179| 0: [TypeAccess] String
|
|
# 179| 5: [BlockStmt] { ... }
|
|
# 179| 3: [Method] f$default
|
|
# 179| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 179| 0: [Parameter] p0
|
|
# 179| 0: [TypeAccess] TestOverloadsWithDefaults
|
|
# 179| 1: [Parameter] p1
|
|
# 179| 0: [TypeAccess] int
|
|
# 179| 2: [Parameter] p2
|
|
# 179| 0: [TypeAccess] String
|
|
# 179| 3: [Parameter] p3
|
|
# 179| 0: [TypeAccess] int
|
|
# 179| 4: [Parameter] p4
|
|
# 179| 0: [TypeAccess] Object
|
|
# 179| 5: [BlockStmt] { ... }
|
|
# 179| 0: [IfStmt] if (...)
|
|
# 179| 0: [EQExpr] ... == ...
|
|
# 179| 0: [AndBitwiseExpr] ... & ...
|
|
# 179| 0: [IntegerLiteral] 2
|
|
# 179| 1: [VarAccess] p3
|
|
# 179| 1: [IntegerLiteral] 0
|
|
# 179| 1: [ExprStmt] <Expr>;
|
|
# 179| 0: [AssignExpr] ...=...
|
|
# 179| 0: [VarAccess] p2
|
|
# 179| 1: [StringLiteral] "Hello world"
|
|
# 179| 1: [ReturnStmt] return ...
|
|
# 179| 0: [MethodCall] f(...)
|
|
# 179| -1: [VarAccess] p0
|
|
# 179| 0: [VarAccess] p1
|
|
# 179| 1: [VarAccess] p2
|
|
# 180| 4: [Method] f
|
|
# 180| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 180| 0: [Parameter] z
|
|
# 180| 0: [TypeAccess] String
|
|
# 180| 1: [Parameter] w
|
|
# 180| 0: [TypeAccess] int
|
|
# 180| 5: [BlockStmt] { ... }
|
|
# 180| 5: [Method] f$default
|
|
# 180| 3: [TypeAccess] Unit
|
|
#-----| 4: (Parameters)
|
|
# 180| 0: [Parameter] p0
|
|
# 180| 0: [TypeAccess] TestOverloadsWithDefaults
|
|
# 180| 1: [Parameter] p1
|
|
# 180| 0: [TypeAccess] String
|
|
# 180| 2: [Parameter] p2
|
|
# 180| 0: [TypeAccess] int
|
|
# 180| 3: [Parameter] p3
|
|
# 180| 0: [TypeAccess] int
|
|
# 180| 4: [Parameter] p4
|
|
# 180| 0: [TypeAccess] Object
|
|
# 180| 5: [BlockStmt] { ... }
|
|
# 180| 0: [IfStmt] if (...)
|
|
# 180| 0: [EQExpr] ... == ...
|
|
# 180| 0: [AndBitwiseExpr] ... & ...
|
|
# 180| 0: [IntegerLiteral] 2
|
|
# 180| 1: [VarAccess] p3
|
|
# 180| 1: [IntegerLiteral] 0
|
|
# 180| 1: [ExprStmt] <Expr>;
|
|
# 180| 0: [AssignExpr] ...=...
|
|
# 180| 0: [VarAccess] p2
|
|
# 180| 1: [IntegerLiteral] 0
|
|
# 180| 1: [ReturnStmt] return ...
|
|
# 180| 0: [MethodCall] f(...)
|
|
# 180| -1: [VarAccess] p0
|
|
# 180| 0: [VarAccess] p1
|
|
# 180| 1: [VarAccess] p2
|
|
# 226| 18: [Class] VarargsConstructorTest
|
|
# 226| 1: [Constructor] VarargsConstructorTest
|
|
#-----| 4: (Parameters)
|
|
# 226| 0: [Parameter] x
|
|
# 226| 0: [TypeAccess] String
|
|
# 226| 1: [Parameter] y
|
|
# 226| 0: [TypeAccess] String[]
|
|
# 226| 0: [WildcardTypeAccess] ? ...
|
|
# 226| 0: [TypeAccess] String
|
|
# 226| 5: [BlockStmt] { ... }
|
|
# 226| 0: [SuperConstructorInvocationStmt] super(...)
|
|
# 226| 1: [BlockStmt] { ... }
|
|
# 228| 0: [ExprStmt] <Expr>;
|
|
# 228| 0: [MethodCall] sink(...)
|
|
# 228| -1: [TypeAccess] TestKt
|
|
# 228| 0: [VarAccess] x
|