mirror of
https://github.com/github/codeql.git
synced 2025-12-16 16:53:25 +01:00
b95092ef1c
This counteracts the movement of synth children away from the node from which they take their location, following the decision to take the index of synth children of real parents into account.
3300 lines
173 KiB
Plaintext
3300 lines
173 KiB
Plaintext
gems/Gemfile:
|
|
# 1| [Toplevel] Gemfile
|
|
# 1| getStmt: [MethodCall] call to source
|
|
# 1| getReceiver: [SelfVariableAccess] self
|
|
# 1| getArgument: [StringLiteral] "https://rubygems.org"
|
|
# 1| getComponent: [StringTextComponent] https://rubygems.org
|
|
# 3| getStmt: [MethodCall] call to gem
|
|
# 3| getReceiver: [SelfVariableAccess] self
|
|
# 3| getArgument: [StringLiteral] "foo_gem"
|
|
# 3| getComponent: [StringTextComponent] foo_gem
|
|
# 3| getArgument: [StringLiteral] "~> 2.0"
|
|
# 3| getComponent: [StringTextComponent] ~> 2.0
|
|
# 5| getStmt: [MethodCall] call to source
|
|
# 5| getReceiver: [SelfVariableAccess] self
|
|
# 5| getArgument: [StringLiteral] "https://gems.example.com"
|
|
# 5| getComponent: [StringTextComponent] https://gems.example.com
|
|
# 5| getBlock: [DoBlock] do ... end
|
|
# 6| getStmt: [MethodCall] call to gem
|
|
# 6| getReceiver: [SelfVariableAccess] self
|
|
# 6| getArgument: [StringLiteral] "my_gem"
|
|
# 6| getComponent: [StringTextComponent] my_gem
|
|
# 6| getArgument: [StringLiteral] "1.0"
|
|
# 6| getComponent: [StringTextComponent] 1.0
|
|
# 7| getStmt: [MethodCall] call to gem
|
|
# 7| getReceiver: [SelfVariableAccess] self
|
|
# 7| getArgument: [StringLiteral] "another_gem"
|
|
# 7| getComponent: [StringTextComponent] another_gem
|
|
# 7| getArgument: [StringLiteral] "3.1.4"
|
|
# 7| getComponent: [StringTextComponent] 3.1.4
|
|
calls/calls.rb:
|
|
# 1| [Toplevel] calls.rb
|
|
# 2| getStmt: [MethodCall] call to foo
|
|
# 2| getReceiver: [SelfVariableAccess] self
|
|
# 5| getStmt: [MethodCall] call to bar
|
|
# 5| getReceiver: [ConstantReadAccess] Foo
|
|
# 8| getStmt: [MethodCall] call to bar
|
|
# 8| getReceiver: [IntegerLiteral] 123
|
|
# 11| getStmt: [MethodCall] call to foo
|
|
# 11| getReceiver: [SelfVariableAccess] self
|
|
# 11| getArgument: [IntegerLiteral] 0
|
|
# 11| getArgument: [IntegerLiteral] 1
|
|
# 11| getArgument: [IntegerLiteral] 2
|
|
# 14| getStmt: [MethodCall] call to foo
|
|
# 14| getReceiver: [SelfVariableAccess] self
|
|
# 14| getBlock: [BraceBlock] { ... }
|
|
# 14| getParameter: [SimpleParameter] x
|
|
# 14| getDefiningAccess: [LocalVariableAccess] x
|
|
# 14| getStmt: [AddExpr] ... + ...
|
|
# 14| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 14| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 17| getStmt: [MethodCall] call to foo
|
|
# 17| getReceiver: [SelfVariableAccess] self
|
|
# 17| getBlock: [DoBlock] do ... end
|
|
# 17| getParameter: [SimpleParameter] x
|
|
# 17| getDefiningAccess: [LocalVariableAccess] x
|
|
# 18| getStmt: [AddExpr] ... + ...
|
|
# 18| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 18| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 22| getStmt: [MethodCall] call to bar
|
|
# 22| getReceiver: [IntegerLiteral] 123
|
|
# 22| getArgument: [StringLiteral] "foo"
|
|
# 22| getComponent: [StringTextComponent] foo
|
|
# 22| getBlock: [DoBlock] do ... end
|
|
# 22| getParameter: [SimpleParameter] x
|
|
# 22| getDefiningAccess: [LocalVariableAccess] x
|
|
# 23| getStmt: [AddExpr] ... + ...
|
|
# 23| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 23| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 27| getStmt: [Method] method_that_yields
|
|
# 28| getStmt: [YieldCall] yield ...
|
|
# 32| getStmt: [Method] another_method_that_yields
|
|
# 33| getStmt: [YieldCall] yield ...
|
|
# 33| getArgument: [IntegerLiteral] 100
|
|
# 33| getArgument: [IntegerLiteral] 200
|
|
# 43| getStmt: [MethodCall] call to foo
|
|
# 43| getReceiver: [SelfVariableAccess] self
|
|
# 44| getStmt: [MethodCall] call to foo
|
|
# 44| getReceiver: [ConstantReadAccess] X
|
|
# 47| getStmt: [ParenthesizedExpr] ( ... )
|
|
# 47| getStmt: [MethodCall] call to foo
|
|
# 47| getReceiver: [SelfVariableAccess] self
|
|
# 48| getStmt: [ParenthesizedExpr] ( ... )
|
|
# 48| getStmt: [MethodCall] call to foo
|
|
# 48| getReceiver: [ConstantReadAccess] X
|
|
# 51| getStmt: [MethodCall] call to some_func
|
|
# 51| getReceiver: [SelfVariableAccess] self
|
|
# 51| getArgument: [MethodCall] call to foo
|
|
# 51| getReceiver: [SelfVariableAccess] self
|
|
# 52| getStmt: [MethodCall] call to some_func
|
|
# 52| getReceiver: [SelfVariableAccess] self
|
|
# 52| getArgument: [MethodCall] call to foo
|
|
# 52| getReceiver: [ConstantReadAccess] X
|
|
# 55| getStmt: [ArrayLiteral] [...]
|
|
# 55| getElement: [MethodCall] call to foo
|
|
# 55| getReceiver: [SelfVariableAccess] self
|
|
# 56| getStmt: [ArrayLiteral] [...]
|
|
# 56| getElement: [MethodCall] call to foo
|
|
# 56| getReceiver: [ConstantReadAccess] X
|
|
# 59| getStmt: [AssignExpr] ... = ...
|
|
# 59| getAnOperand/getLeftOperand: [LocalVariableAccess] var1
|
|
# 59| getAnOperand/getRightOperand: [MethodCall] call to foo
|
|
# 59| getReceiver: [SelfVariableAccess] self
|
|
# 60| getStmt: [AssignExpr] ... = ...
|
|
# 60| getAnOperand/getLeftOperand: [LocalVariableAccess] var1
|
|
# 60| getAnOperand/getRightOperand: [MethodCall] call to foo
|
|
# 60| getReceiver: [ConstantReadAccess] X
|
|
# 63| getStmt: [AssignAddExpr] ... += ...
|
|
# 63| getAnOperand/getLeftOperand: [LocalVariableAccess] var1
|
|
# 63| getAnOperand/getRightOperand: [MethodCall] call to bar
|
|
# 63| getReceiver: [SelfVariableAccess] self
|
|
# 64| getStmt: [AssignAddExpr] ... += ...
|
|
# 64| getAnOperand/getLeftOperand: [LocalVariableAccess] var1
|
|
# 64| getAnOperand/getRightOperand: [MethodCall] call to bar
|
|
# 64| getReceiver: [ConstantReadAccess] X
|
|
# 67| getStmt: [AssignExpr] ... = ...
|
|
# 67| getAnOperand/getLeftOperand: [LocalVariableAccess] var1
|
|
# 67| getAnOperand/getRightOperand: [ArgumentList] ..., ...
|
|
# 67| getElement: [MethodCall] call to foo
|
|
# 67| getReceiver: [SelfVariableAccess] self
|
|
# 67| getElement: [MethodCall] call to bar
|
|
# 67| getReceiver: [ConstantReadAccess] X
|
|
# 70| getStmt: [BeginExpr] begin ...
|
|
# 71| getStmt: [MethodCall] call to foo
|
|
# 71| getReceiver: [SelfVariableAccess] self
|
|
# 72| getStmt: [MethodCall] call to foo
|
|
# 72| getReceiver: [ConstantReadAccess] X
|
|
# 76| getBeginBlock: [BeginBlock] BEGIN { ... }
|
|
# 76| getStmt: [MethodCall] call to foo
|
|
# 76| getReceiver: [SelfVariableAccess] self
|
|
# 76| getStmt: [MethodCall] call to bar
|
|
# 76| getReceiver: [ConstantReadAccess] X
|
|
# 79| getStmt: [EndBlock] END { ... }
|
|
# 79| getStmt: [MethodCall] call to foo
|
|
# 79| getReceiver: [SelfVariableAccess] self
|
|
# 79| getStmt: [MethodCall] call to bar
|
|
# 79| getReceiver: [ConstantReadAccess] X
|
|
# 82| getStmt: [AddExpr] ... + ...
|
|
# 82| getAnOperand/getLeftOperand/getReceiver: [MethodCall] call to foo
|
|
# 82| getReceiver: [SelfVariableAccess] self
|
|
# 82| getAnOperand/getArgument/getRightOperand: [MethodCall] call to bar
|
|
# 82| getReceiver: [ConstantReadAccess] X
|
|
# 85| getStmt: [NotExpr] ! ...
|
|
# 85| getAnOperand/getOperand/getReceiver: [MethodCall] call to foo
|
|
# 85| getReceiver: [SelfVariableAccess] self
|
|
# 86| getStmt: [ComplementExpr] ~ ...
|
|
# 86| getAnOperand/getOperand/getReceiver: [MethodCall] call to bar
|
|
# 86| getReceiver: [ConstantReadAccess] X
|
|
# 89| getStmt: [MethodCall] call to foo
|
|
# 89| getReceiver: [SelfVariableAccess] self
|
|
# 89| getBlock: [BraceBlock] { ... }
|
|
# 89| getStmt: [MethodCall] call to bar
|
|
# 89| getReceiver: [SelfVariableAccess] self
|
|
# 89| getStmt: [MethodCall] call to baz
|
|
# 89| getReceiver: [ConstantReadAccess] X
|
|
# 92| getStmt: [MethodCall] call to foo
|
|
# 92| getReceiver: [SelfVariableAccess] self
|
|
# 92| getBlock: [DoBlock] do ... end
|
|
# 93| getStmt: [MethodCall] call to bar
|
|
# 93| getReceiver: [SelfVariableAccess] self
|
|
# 94| getStmt: [MethodCall] call to baz
|
|
# 94| getReceiver: [ConstantReadAccess] X
|
|
# 98| getStmt: [MethodCall] call to bar
|
|
# 98| getReceiver: [MethodCall] call to foo
|
|
# 98| getReceiver: [SelfVariableAccess] self
|
|
# 99| getStmt: [MethodCall] call to baz
|
|
# 99| getReceiver: [MethodCall] call to bar
|
|
# 99| getReceiver: [SelfVariableAccess] self
|
|
# 103| getStmt: [CaseExpr] case ...
|
|
# 103| getValue: [MethodCall] call to foo
|
|
# 103| getReceiver: [SelfVariableAccess] self
|
|
# 104| getBranch: [WhenClause] when ...
|
|
# 104| getPattern: [MethodCall] call to bar
|
|
# 104| getReceiver: [SelfVariableAccess] self
|
|
# 104| getBody: [StmtSequence] then ...
|
|
# 105| getStmt: [MethodCall] call to baz
|
|
# 105| getReceiver: [SelfVariableAccess] self
|
|
# 107| getStmt: [CaseExpr] case ...
|
|
# 107| getValue: [MethodCall] call to foo
|
|
# 107| getReceiver: [ConstantReadAccess] X
|
|
# 108| getBranch: [WhenClause] when ...
|
|
# 108| getPattern: [MethodCall] call to bar
|
|
# 108| getReceiver: [ConstantReadAccess] X
|
|
# 108| getBody: [StmtSequence] then ...
|
|
# 109| getStmt: [MethodCall] call to baz
|
|
# 109| getReceiver: [ConstantReadAccess] X
|
|
# 113| getStmt: [ClassDeclaration] MyClass
|
|
# 114| getStmt: [MethodCall] call to foo
|
|
# 114| getReceiver: [SelfVariableAccess] self
|
|
# 115| getStmt: [MethodCall] call to bar
|
|
# 115| getReceiver: [ConstantReadAccess] X
|
|
# 119| getStmt: [ClassDeclaration] MyClass
|
|
# 119| getSuperclassExpr: [MethodCall] call to foo
|
|
# 119| getReceiver: [SelfVariableAccess] self
|
|
# 121| getStmt: [ClassDeclaration] MyClass2
|
|
# 121| getSuperclassExpr: [MethodCall] call to foo
|
|
# 121| getReceiver: [ConstantReadAccess] X
|
|
# 125| getStmt: [SingletonClass] class << ...
|
|
# 125| getValue: [MethodCall] call to foo
|
|
# 125| getReceiver: [SelfVariableAccess] self
|
|
# 126| getStmt: [MethodCall] call to bar
|
|
# 126| getReceiver: [SelfVariableAccess] self
|
|
# 128| getStmt: [SingletonClass] class << ...
|
|
# 128| getValue: [MethodCall] call to foo
|
|
# 128| getReceiver: [ConstantReadAccess] X
|
|
# 129| getStmt: [MethodCall] call to bar
|
|
# 129| getReceiver: [ConstantReadAccess] X
|
|
# 133| getStmt: [Method] some_method
|
|
# 134| getStmt: [MethodCall] call to foo
|
|
# 134| getReceiver: [SelfVariableAccess] self
|
|
# 135| getStmt: [MethodCall] call to bar
|
|
# 135| getReceiver: [ConstantReadAccess] X
|
|
# 139| getStmt: [SingletonMethod] some_method
|
|
# 139| getObject: [MethodCall] call to foo
|
|
# 139| getReceiver: [SelfVariableAccess] self
|
|
# 140| getStmt: [MethodCall] call to bar
|
|
# 140| getReceiver: [SelfVariableAccess] self
|
|
# 141| getStmt: [MethodCall] call to baz
|
|
# 141| getReceiver: [ConstantReadAccess] X
|
|
# 145| getStmt: [Method] method_with_keyword_param
|
|
# 145| getParameter: [KeywordParameter] keyword
|
|
# 145| getDefiningAccess: [LocalVariableAccess] keyword
|
|
# 145| getDefaultValue: [MethodCall] call to foo
|
|
# 145| getReceiver: [SelfVariableAccess] self
|
|
# 147| getStmt: [Method] method_with_keyword_param2
|
|
# 147| getParameter: [KeywordParameter] keyword
|
|
# 147| getDefiningAccess: [LocalVariableAccess] keyword
|
|
# 147| getDefaultValue: [MethodCall] call to foo
|
|
# 147| getReceiver: [ConstantReadAccess] X
|
|
# 151| getStmt: [Method] method_with_optional_param
|
|
# 151| getParameter: [OptionalParameter] param
|
|
# 151| getDefiningAccess: [LocalVariableAccess] param
|
|
# 151| getDefaultValue: [MethodCall] call to foo
|
|
# 151| getReceiver: [SelfVariableAccess] self
|
|
# 153| getStmt: [Method] method_with_optional_param2
|
|
# 153| getParameter: [OptionalParameter] param
|
|
# 153| getDefiningAccess: [LocalVariableAccess] param
|
|
# 153| getDefaultValue: [MethodCall] call to foo
|
|
# 153| getReceiver: [ConstantReadAccess] X
|
|
# 157| getStmt: [ModuleDeclaration] SomeModule
|
|
# 158| getStmt: [MethodCall] call to foo
|
|
# 158| getReceiver: [SelfVariableAccess] self
|
|
# 159| getStmt: [MethodCall] call to bar
|
|
# 159| getReceiver: [ConstantReadAccess] X
|
|
# 163| getStmt: [TernaryIfExpr] ... ? ... : ...
|
|
# 163| getCondition: [MethodCall] call to foo
|
|
# 163| getReceiver: [SelfVariableAccess] self
|
|
# 163| getBranch/getThen: [MethodCall] call to bar
|
|
# 163| getReceiver: [SelfVariableAccess] self
|
|
# 163| getBranch/getElse: [MethodCall] call to baz
|
|
# 163| getReceiver: [SelfVariableAccess] self
|
|
# 164| getStmt: [TernaryIfExpr] ... ? ... : ...
|
|
# 164| getCondition: [MethodCall] call to foo
|
|
# 164| getReceiver: [ConstantReadAccess] X
|
|
# 164| getBranch/getThen: [MethodCall] call to bar
|
|
# 164| getReceiver: [ConstantReadAccess] X
|
|
# 164| getBranch/getElse: [MethodCall] call to baz
|
|
# 164| getReceiver: [ConstantReadAccess] X
|
|
# 167| getStmt: [IfExpr] if ...
|
|
# 167| getCondition: [MethodCall] call to foo
|
|
# 167| getReceiver: [SelfVariableAccess] self
|
|
# 167| getBranch/getThen: [StmtSequence] then ...
|
|
# 168| getStmt: [MethodCall] call to wibble
|
|
# 168| getReceiver: [SelfVariableAccess] self
|
|
# 169| getBranch/getElse: [IfExpr] elsif ...
|
|
# 169| getCondition: [MethodCall] call to bar
|
|
# 169| getReceiver: [SelfVariableAccess] self
|
|
# 169| getBranch/getThen: [StmtSequence] then ...
|
|
# 170| getStmt: [MethodCall] call to wobble
|
|
# 170| getReceiver: [SelfVariableAccess] self
|
|
# 171| getBranch/getElse: [StmtSequence] else ...
|
|
# 172| getStmt: [MethodCall] call to wabble
|
|
# 172| getReceiver: [SelfVariableAccess] self
|
|
# 174| getStmt: [IfExpr] if ...
|
|
# 174| getCondition: [MethodCall] call to foo
|
|
# 174| getReceiver: [ConstantReadAccess] X
|
|
# 174| getBranch/getThen: [StmtSequence] then ...
|
|
# 175| getStmt: [MethodCall] call to wibble
|
|
# 175| getReceiver: [ConstantReadAccess] X
|
|
# 176| getBranch/getElse: [IfExpr] elsif ...
|
|
# 176| getCondition: [MethodCall] call to bar
|
|
# 176| getReceiver: [ConstantReadAccess] X
|
|
# 176| getBranch/getThen: [StmtSequence] then ...
|
|
# 177| getStmt: [MethodCall] call to wobble
|
|
# 177| getReceiver: [ConstantReadAccess] X
|
|
# 178| getBranch/getElse: [StmtSequence] else ...
|
|
# 179| getStmt: [MethodCall] call to wabble
|
|
# 179| getReceiver: [ConstantReadAccess] X
|
|
# 183| getStmt: [IfModifierExpr] ... if ...
|
|
# 183| getBody/getBranch: [MethodCall] call to bar
|
|
# 183| getReceiver: [SelfVariableAccess] self
|
|
# 183| getCondition: [MethodCall] call to foo
|
|
# 183| getReceiver: [SelfVariableAccess] self
|
|
# 184| getStmt: [IfModifierExpr] ... if ...
|
|
# 184| getBody/getBranch: [MethodCall] call to bar
|
|
# 184| getReceiver: [ConstantReadAccess] X
|
|
# 184| getCondition: [MethodCall] call to foo
|
|
# 184| getReceiver: [ConstantReadAccess] X
|
|
# 187| getStmt: [UnlessExpr] unless ...
|
|
# 187| getCondition: [MethodCall] call to foo
|
|
# 187| getReceiver: [SelfVariableAccess] self
|
|
# 187| getBranch/getThen: [StmtSequence] then ...
|
|
# 188| getStmt: [MethodCall] call to bar
|
|
# 188| getReceiver: [SelfVariableAccess] self
|
|
# 190| getStmt: [UnlessExpr] unless ...
|
|
# 190| getCondition: [MethodCall] call to foo
|
|
# 190| getReceiver: [ConstantReadAccess] X
|
|
# 190| getBranch/getThen: [StmtSequence] then ...
|
|
# 191| getStmt: [MethodCall] call to bar
|
|
# 191| getReceiver: [ConstantReadAccess] X
|
|
# 195| getStmt: [UnlessModifierExpr] ... unless ...
|
|
# 195| getBody/getBranch: [MethodCall] call to bar
|
|
# 195| getReceiver: [SelfVariableAccess] self
|
|
# 195| getCondition: [MethodCall] call to foo
|
|
# 195| getReceiver: [SelfVariableAccess] self
|
|
# 196| getStmt: [UnlessModifierExpr] ... unless ...
|
|
# 196| getBody/getBranch: [MethodCall] call to bar
|
|
# 196| getReceiver: [ConstantReadAccess] X
|
|
# 196| getCondition: [MethodCall] call to foo
|
|
# 196| getReceiver: [ConstantReadAccess] X
|
|
# 199| getStmt: [WhileExpr] while ...
|
|
# 199| getCondition: [MethodCall] call to foo
|
|
# 199| getReceiver: [SelfVariableAccess] self
|
|
# 199| getBody: [StmtSequence] do ...
|
|
# 200| getStmt: [MethodCall] call to bar
|
|
# 200| getReceiver: [SelfVariableAccess] self
|
|
# 202| getStmt: [WhileExpr] while ...
|
|
# 202| getCondition: [MethodCall] call to foo
|
|
# 202| getReceiver: [ConstantReadAccess] X
|
|
# 202| getBody: [StmtSequence] do ...
|
|
# 203| getStmt: [MethodCall] call to bar
|
|
# 203| getReceiver: [ConstantReadAccess] X
|
|
# 207| getStmt: [WhileModifierExpr] ... while ...
|
|
# 207| getBody: [MethodCall] call to bar
|
|
# 207| getReceiver: [SelfVariableAccess] self
|
|
# 207| getCondition: [MethodCall] call to foo
|
|
# 207| getReceiver: [SelfVariableAccess] self
|
|
# 208| getStmt: [WhileModifierExpr] ... while ...
|
|
# 208| getBody: [MethodCall] call to bar
|
|
# 208| getReceiver: [ConstantReadAccess] X
|
|
# 208| getCondition: [MethodCall] call to foo
|
|
# 208| getReceiver: [ConstantReadAccess] X
|
|
# 211| getStmt: [UntilExpr] until ...
|
|
# 211| getCondition: [MethodCall] call to foo
|
|
# 211| getReceiver: [SelfVariableAccess] self
|
|
# 211| getBody: [StmtSequence] do ...
|
|
# 212| getStmt: [MethodCall] call to bar
|
|
# 212| getReceiver: [SelfVariableAccess] self
|
|
# 214| getStmt: [UntilExpr] until ...
|
|
# 214| getCondition: [MethodCall] call to foo
|
|
# 214| getReceiver: [ConstantReadAccess] X
|
|
# 214| getBody: [StmtSequence] do ...
|
|
# 215| getStmt: [MethodCall] call to bar
|
|
# 215| getReceiver: [ConstantReadAccess] X
|
|
# 219| getStmt: [UntilModifierExpr] ... until ...
|
|
# 219| getBody: [MethodCall] call to bar
|
|
# 219| getReceiver: [SelfVariableAccess] self
|
|
# 219| getCondition: [MethodCall] call to foo
|
|
# 219| getReceiver: [SelfVariableAccess] self
|
|
# 220| getStmt: [UntilModifierExpr] ... until ...
|
|
# 220| getBody: [MethodCall] call to bar
|
|
# 220| getReceiver: [ConstantReadAccess] X
|
|
# 220| getCondition: [MethodCall] call to foo
|
|
# 220| getReceiver: [ConstantReadAccess] X
|
|
# 223| getStmt: [ForExpr] for ... in ...
|
|
# 223| getPattern: [LocalVariableAccess] x
|
|
# 223| getValue: [MethodCall] call to bar
|
|
# 223| getReceiver: [SelfVariableAccess] self
|
|
# 223| getBody: [StmtSequence] do ...
|
|
# 224| getStmt: [MethodCall] call to baz
|
|
# 224| getReceiver: [SelfVariableAccess] self
|
|
# 226| getStmt: [ForExpr] for ... in ...
|
|
# 226| getPattern: [LocalVariableAccess] x
|
|
# 226| getValue: [MethodCall] call to bar
|
|
# 226| getReceiver: [ConstantReadAccess] X
|
|
# 226| getBody: [StmtSequence] do ...
|
|
# 227| getStmt: [MethodCall] call to baz
|
|
# 227| getReceiver: [ConstantReadAccess] X
|
|
# 231| getStmt: [ElementReference] ...[...]
|
|
# 231| getReceiver: [MethodCall] call to foo
|
|
# 231| getReceiver: [SelfVariableAccess] self
|
|
# 231| getArgument: [MethodCall] call to bar
|
|
# 231| getReceiver: [SelfVariableAccess] self
|
|
# 232| getStmt: [ElementReference] ...[...]
|
|
# 232| getReceiver: [MethodCall] call to foo
|
|
# 232| getReceiver: [ConstantReadAccess] X
|
|
# 232| getArgument: [MethodCall] call to bar
|
|
# 232| getReceiver: [ConstantReadAccess] X
|
|
# 235| getStmt: [StringLiteral] "foo-#{...}-#{...}"
|
|
# 235| getComponent: [StringTextComponent] foo-
|
|
# 235| getComponent: [StringInterpolationComponent] #{...}
|
|
# 235| getStmt: [MethodCall] call to bar
|
|
# 235| getReceiver: [SelfVariableAccess] self
|
|
# 235| getComponent: [StringTextComponent] -
|
|
# 235| getComponent: [StringInterpolationComponent] #{...}
|
|
# 235| getStmt: [MethodCall] call to baz
|
|
# 235| getReceiver: [ConstantReadAccess] X
|
|
# 238| getStmt: [ConstantReadAccess] Bar
|
|
# 238| getScopeExpr: [MethodCall] call to foo
|
|
# 238| getReceiver: [SelfVariableAccess] self
|
|
# 239| getStmt: [ConstantReadAccess] Bar
|
|
# 239| getScopeExpr: [MethodCall] call to foo
|
|
# 239| getReceiver: [ConstantReadAccess] X
|
|
# 242| getStmt: [RangeLiteral] _ .. _
|
|
# 242| getBegin: [MethodCall] call to foo
|
|
# 242| getReceiver: [SelfVariableAccess] self
|
|
# 242| getEnd: [MethodCall] call to bar
|
|
# 242| getReceiver: [SelfVariableAccess] self
|
|
# 243| getStmt: [RangeLiteral] _ .. _
|
|
# 243| getBegin: [MethodCall] call to foo
|
|
# 243| getReceiver: [ConstantReadAccess] X
|
|
# 243| getEnd: [MethodCall] call to bar
|
|
# 243| getReceiver: [ConstantReadAccess] X
|
|
# 246| getStmt: [HashLiteral] {...}
|
|
# 246| getElement: [Pair] Pair
|
|
# 246| getKey: [MethodCall] call to foo
|
|
# 246| getReceiver: [SelfVariableAccess] self
|
|
# 246| getValue: [MethodCall] call to bar
|
|
# 246| getReceiver: [SelfVariableAccess] self
|
|
# 246| getElement: [Pair] Pair
|
|
# 246| getKey: [MethodCall] call to foo
|
|
# 246| getReceiver: [ConstantReadAccess] X
|
|
# 246| getValue: [MethodCall] call to bar
|
|
# 246| getReceiver: [ConstantReadAccess] X
|
|
# 249| getStmt: [BeginExpr] begin ...
|
|
# 250| getRescue: [RescueClause] rescue ...
|
|
# 250| getException: [MethodCall] call to foo
|
|
# 250| getReceiver: [SelfVariableAccess] self
|
|
# 251| getEnsure: [StmtSequence] ensure ...
|
|
# 251| getStmt: [MethodCall] call to bar
|
|
# 251| getReceiver: [SelfVariableAccess] self
|
|
# 253| getStmt: [BeginExpr] begin ...
|
|
# 254| getRescue: [RescueClause] rescue ...
|
|
# 254| getException: [MethodCall] call to foo
|
|
# 254| getReceiver: [ConstantReadAccess] X
|
|
# 255| getEnsure: [StmtSequence] ensure ...
|
|
# 255| getStmt: [MethodCall] call to bar
|
|
# 255| getReceiver: [ConstantReadAccess] X
|
|
# 259| getStmt: [RescueModifierExpr] ... rescue ...
|
|
# 259| getBody: [MethodCall] call to foo
|
|
# 259| getReceiver: [SelfVariableAccess] self
|
|
# 259| getHandler: [MethodCall] call to bar
|
|
# 259| getReceiver: [SelfVariableAccess] self
|
|
# 260| getStmt: [RescueModifierExpr] ... rescue ...
|
|
# 260| getBody: [MethodCall] call to foo
|
|
# 260| getReceiver: [ConstantReadAccess] X
|
|
# 260| getHandler: [MethodCall] call to bar
|
|
# 260| getReceiver: [ConstantReadAccess] X
|
|
# 263| getStmt: [MethodCall] call to foo
|
|
# 263| getReceiver: [SelfVariableAccess] self
|
|
# 263| getArgument: [BlockArgument] &...
|
|
# 263| getValue: [MethodCall] call to bar
|
|
# 263| getReceiver: [SelfVariableAccess] self
|
|
# 264| getStmt: [MethodCall] call to foo
|
|
# 264| getReceiver: [SelfVariableAccess] self
|
|
# 264| getArgument: [BlockArgument] &...
|
|
# 264| getValue: [MethodCall] call to bar
|
|
# 264| getReceiver: [ConstantReadAccess] X
|
|
# 265| getStmt: [MethodCall] call to foo
|
|
# 265| getReceiver: [SelfVariableAccess] self
|
|
# 265| getArgument: [BlockArgument] &...
|
|
# 267| getStmt: [MethodCall] call to foo
|
|
# 267| getReceiver: [SelfVariableAccess] self
|
|
# 267| getArgument: [SplatExpr] * ...
|
|
# 267| getAnOperand/getOperand/getReceiver: [MethodCall] call to bar
|
|
# 267| getReceiver: [SelfVariableAccess] self
|
|
# 268| getStmt: [MethodCall] call to foo
|
|
# 268| getReceiver: [SelfVariableAccess] self
|
|
# 268| getArgument: [SplatExpr] * ...
|
|
# 268| getAnOperand/getOperand/getReceiver: [MethodCall] call to bar
|
|
# 268| getReceiver: [ConstantReadAccess] X
|
|
# 269| getStmt: [MethodCall] call to foo
|
|
# 269| getReceiver: [SelfVariableAccess] self
|
|
# 269| getArgument: [SplatExpr] * ...
|
|
# 272| getStmt: [MethodCall] call to foo
|
|
# 272| getReceiver: [SelfVariableAccess] self
|
|
# 272| getArgument: [HashSplatExpr] ** ...
|
|
# 272| getAnOperand/getOperand/getReceiver: [MethodCall] call to bar
|
|
# 272| getReceiver: [SelfVariableAccess] self
|
|
# 273| getStmt: [MethodCall] call to foo
|
|
# 273| getReceiver: [SelfVariableAccess] self
|
|
# 273| getArgument: [HashSplatExpr] ** ...
|
|
# 273| getAnOperand/getOperand/getReceiver: [MethodCall] call to bar
|
|
# 273| getReceiver: [ConstantReadAccess] X
|
|
# 274| getStmt: [MethodCall] call to foo
|
|
# 274| getReceiver: [SelfVariableAccess] self
|
|
# 274| getArgument: [HashSplatExpr] ** ...
|
|
# 277| getStmt: [MethodCall] call to foo
|
|
# 277| getReceiver: [SelfVariableAccess] self
|
|
# 277| getArgument: [Pair] Pair
|
|
# 277| getKey: [SymbolLiteral] :blah
|
|
# 277| getComponent: [StringTextComponent] blah
|
|
# 277| getValue: [MethodCall] call to bar
|
|
# 277| getReceiver: [SelfVariableAccess] self
|
|
# 278| getStmt: [MethodCall] call to foo
|
|
# 278| getReceiver: [SelfVariableAccess] self
|
|
# 278| getArgument: [Pair] Pair
|
|
# 278| getKey: [SymbolLiteral] :blah
|
|
# 278| getComponent: [StringTextComponent] blah
|
|
# 278| getValue: [MethodCall] call to bar
|
|
# 278| getReceiver: [ConstantReadAccess] X
|
|
# 283| getStmt: [ClassDeclaration] MyClass
|
|
# 284| getStmt: [Method] my_method
|
|
# 285| getStmt: [SuperCall] super call to my_method
|
|
# 286| getStmt: [SuperCall] super call to my_method
|
|
# 287| getStmt: [SuperCall] super call to my_method
|
|
# 287| getArgument: [StringLiteral] "blah"
|
|
# 287| getComponent: [StringTextComponent] blah
|
|
# 288| getStmt: [SuperCall] super call to my_method
|
|
# 288| getArgument: [IntegerLiteral] 1
|
|
# 288| getArgument: [IntegerLiteral] 2
|
|
# 288| getArgument: [IntegerLiteral] 3
|
|
# 289| getStmt: [SuperCall] super call to my_method
|
|
# 289| getBlock: [BraceBlock] { ... }
|
|
# 289| getParameter: [SimpleParameter] x
|
|
# 289| getDefiningAccess: [LocalVariableAccess] x
|
|
# 289| getStmt: [AddExpr] ... + ...
|
|
# 289| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 289| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 290| getStmt: [SuperCall] super call to my_method
|
|
# 290| getBlock: [DoBlock] do ... end
|
|
# 290| getParameter: [SimpleParameter] x
|
|
# 290| getDefiningAccess: [LocalVariableAccess] x
|
|
# 290| getStmt: [MulExpr] ... * ...
|
|
# 290| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 290| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 2
|
|
# 291| getStmt: [SuperCall] super call to my_method
|
|
# 291| getArgument: [IntegerLiteral] 4
|
|
# 291| getArgument: [IntegerLiteral] 5
|
|
# 291| getBlock: [BraceBlock] { ... }
|
|
# 291| getParameter: [SimpleParameter] x
|
|
# 291| getDefiningAccess: [LocalVariableAccess] x
|
|
# 291| getStmt: [AddExpr] ... + ...
|
|
# 291| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 291| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 100
|
|
# 292| getStmt: [SuperCall] super call to my_method
|
|
# 292| getArgument: [IntegerLiteral] 6
|
|
# 292| getArgument: [IntegerLiteral] 7
|
|
# 292| getBlock: [DoBlock] do ... end
|
|
# 292| getParameter: [SimpleParameter] x
|
|
# 292| getDefiningAccess: [LocalVariableAccess] x
|
|
# 292| getStmt: [AddExpr] ... + ...
|
|
# 292| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 292| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 200
|
|
# 300| getStmt: [ClassDeclaration] AnotherClass
|
|
# 301| getStmt: [Method] another_method
|
|
# 302| getStmt: [MethodCall] call to super
|
|
# 302| getReceiver: [MethodCall] call to foo
|
|
# 302| getReceiver: [SelfVariableAccess] self
|
|
# 303| getStmt: [MethodCall] call to super
|
|
# 303| getReceiver: [SelfVariableAccess] self
|
|
# 304| getStmt: [MethodCall] call to super
|
|
# 304| getReceiver: [SuperCall] super call to another_method
|
|
# 309| getStmt: [MethodCall] call to call
|
|
# 309| getReceiver: [MethodCall] call to foo
|
|
# 309| getReceiver: [SelfVariableAccess] self
|
|
# 310| getStmt: [MethodCall] call to call
|
|
# 310| getReceiver: [MethodCall] call to foo
|
|
# 310| getReceiver: [SelfVariableAccess] self
|
|
# 310| getArgument: [IntegerLiteral] 1
|
|
# 313| getStmt: [AssignExpr] ... = ...
|
|
# 313| getAnOperand/getLeftOperand: [MethodCall] call to foo
|
|
# 313| getReceiver: [SelfVariableAccess] self
|
|
# 313| getAnOperand/getRightOperand: [IntegerLiteral] 10
|
|
# 314| getStmt: [AssignExpr] ... = ...
|
|
# 314| getAnOperand/getLeftOperand: [ElementReference] ...[...]
|
|
# 314| getReceiver: [MethodCall] call to foo
|
|
# 314| getReceiver: [SelfVariableAccess] self
|
|
# 314| getArgument: [IntegerLiteral] 0
|
|
# 314| getAnOperand/getRightOperand: [IntegerLiteral] 10
|
|
# 315| getStmt: [AssignExpr] ... = ...
|
|
# 315| getAnOperand/getLeftOperand: [DestructuredLhsExpr] (..., ...)
|
|
# 315| getElement: [MethodCall] call to foo
|
|
# 315| getReceiver: [SelfVariableAccess] self
|
|
# 315| getElement: [MethodCall] call to bar
|
|
# 315| getReceiver: [SelfVariableAccess] self
|
|
# 315| getElement: [ElementReference] ...[...]
|
|
# 315| getReceiver: [MethodCall] call to foo
|
|
# 315| getReceiver: [SelfVariableAccess] self
|
|
# 315| getArgument: [IntegerLiteral] 4
|
|
# 315| getAnOperand/getRightOperand: [ArrayLiteral] [...]
|
|
# 315| getElement: [IntegerLiteral] 1
|
|
# 315| getElement: [IntegerLiteral] 2
|
|
# 315| getElement: [IntegerLiteral] 3
|
|
# 315| getElement: [IntegerLiteral] 4
|
|
# 316| getStmt: [AssignExpr] ... = ...
|
|
# 316| getAnOperand/getLeftOperand: [DestructuredLhsExpr] (..., ...)
|
|
# 316| getElement: [LocalVariableAccess] a
|
|
# 316| getElement: [ElementReference] ...[...]
|
|
# 316| getReceiver: [MethodCall] call to foo
|
|
# 316| getReceiver: [SelfVariableAccess] self
|
|
# 316| getArgument: [IntegerLiteral] 5
|
|
# 316| getAnOperand/getRightOperand: [ArrayLiteral] [...]
|
|
# 316| getElement: [IntegerLiteral] 1
|
|
# 316| getElement: [IntegerLiteral] 2
|
|
# 316| getElement: [IntegerLiteral] 3
|
|
# 317| getStmt: [AssignAddExpr] ... += ...
|
|
# 317| getAnOperand/getLeftOperand: [MethodCall] call to count
|
|
# 317| getReceiver: [SelfVariableAccess] self
|
|
# 317| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 318| getStmt: [AssignAddExpr] ... += ...
|
|
# 318| getAnOperand/getLeftOperand: [ElementReference] ...[...]
|
|
# 318| getReceiver: [MethodCall] call to foo
|
|
# 318| getReceiver: [SelfVariableAccess] self
|
|
# 318| getArgument: [IntegerLiteral] 0
|
|
# 318| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 319| getStmt: [AssignMulExpr] ... *= ...
|
|
# 319| getAnOperand/getLeftOperand: [ElementReference] ...[...]
|
|
# 319| getReceiver: [MethodCall] call to bar
|
|
# 319| getReceiver: [MethodCall] call to foo
|
|
# 319| getReceiver: [SelfVariableAccess] self
|
|
# 319| getArgument: [IntegerLiteral] 0
|
|
# 319| getArgument: [MethodCall] call to baz
|
|
# 319| getReceiver: [MethodCall] call to foo
|
|
# 319| getReceiver: [SelfVariableAccess] self
|
|
# 319| getArgument: [AddExpr] ... + ...
|
|
# 319| getAnOperand/getLeftOperand/getReceiver: [MethodCall] call to boo
|
|
# 319| getReceiver: [MethodCall] call to foo
|
|
# 319| getReceiver: [SelfVariableAccess] self
|
|
# 319| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 319| getAnOperand/getRightOperand: [IntegerLiteral] 2
|
|
# 322| getStmt: [Method] foo
|
|
# 322| getStmt: [MethodCall] call to bar
|
|
# 322| getReceiver: [SelfVariableAccess] self
|
|
# 323| getStmt: [Method] foo
|
|
# 323| getStmt: [MethodCall] call to bar
|
|
# 323| getReceiver: [SelfVariableAccess] self
|
|
# 324| getStmt: [Method] foo
|
|
# 324| getParameter: [SimpleParameter] x
|
|
# 324| getDefiningAccess: [LocalVariableAccess] x
|
|
# 324| getStmt: [MethodCall] call to bar
|
|
# 324| getReceiver: [SelfVariableAccess] self
|
|
# 325| getStmt: [SingletonMethod] foo
|
|
# 325| getObject: [ConstantReadAccess] Object
|
|
# 325| getStmt: [MethodCall] call to bar
|
|
# 325| getReceiver: [SelfVariableAccess] self
|
|
# 326| getStmt: [SingletonMethod] foo
|
|
# 326| getObject: [ConstantReadAccess] Object
|
|
# 326| getParameter: [SimpleParameter] x
|
|
# 326| getDefiningAccess: [LocalVariableAccess] x
|
|
# 326| getStmt: [MethodCall] call to bar
|
|
# 326| getReceiver: [SelfVariableAccess] self
|
|
# 327| getStmt: [Method] foo
|
|
# 327| getStmt: [RescueModifierExpr] ... rescue ...
|
|
# 327| getBody: [MethodCall] call to bar
|
|
# 327| getReceiver: [SelfVariableAccess] self
|
|
# 327| getHandler: [ParenthesizedExpr] ( ... )
|
|
# 327| getStmt: [MethodCall] call to print
|
|
# 327| getReceiver: [SelfVariableAccess] self
|
|
# 327| getArgument: [StringLiteral] "error"
|
|
# 327| getComponent: [StringTextComponent] error
|
|
# 330| getStmt: [Method] foo
|
|
# 330| getParameter: [ForwardParameter] ...
|
|
# 331| getStmt: [SuperCall] super call to foo
|
|
# 331| getArgument: [ForwardedArguments] ...
|
|
# 334| getStmt: [Method] foo
|
|
# 334| getParameter: [SimpleParameter] a
|
|
# 334| getDefiningAccess: [LocalVariableAccess] a
|
|
# 334| getParameter: [SimpleParameter] b
|
|
# 334| getDefiningAccess: [LocalVariableAccess] b
|
|
# 334| getParameter: [ForwardParameter] ...
|
|
# 335| getStmt: [MethodCall] call to bar
|
|
# 335| getReceiver: [SelfVariableAccess] self
|
|
# 335| getArgument: [LocalVariableAccess] b
|
|
# 335| getArgument: [ForwardedArguments] ...
|
|
# 339| getStmt: [ForExpr] for ... in ...
|
|
# 339| getPattern: [DestructuredLhsExpr] (..., ...)
|
|
# 339| getElement: [LocalVariableAccess] x
|
|
# 339| getElement: [LocalVariableAccess] y
|
|
# 339| getElement: [LocalVariableAccess] z
|
|
# 339| getValue: [ArrayLiteral] [...]
|
|
# 339| getElement: [ArrayLiteral] [...]
|
|
# 339| getElement: [IntegerLiteral] 1
|
|
# 339| getElement: [IntegerLiteral] 2
|
|
# 339| getElement: [IntegerLiteral] 3
|
|
# 339| getElement: [ArrayLiteral] [...]
|
|
# 339| getElement: [IntegerLiteral] 4
|
|
# 339| getElement: [IntegerLiteral] 5
|
|
# 339| getElement: [IntegerLiteral] 6
|
|
# 339| getBody: [StmtSequence] do ...
|
|
# 340| getStmt: [MethodCall] call to foo
|
|
# 340| getReceiver: [SelfVariableAccess] self
|
|
# 340| getArgument: [LocalVariableAccess] x
|
|
# 340| getArgument: [LocalVariableAccess] y
|
|
# 340| getArgument: [LocalVariableAccess] z
|
|
# 343| getStmt: [MethodCall] call to foo
|
|
# 343| getReceiver: [SelfVariableAccess] self
|
|
# 343| getArgument: [Pair] Pair
|
|
# 343| getKey: [SymbolLiteral] :x
|
|
# 343| getComponent: [StringTextComponent] x
|
|
# 343| getValue: [IntegerLiteral] 42
|
|
# 344| getStmt: [MethodCall] call to foo
|
|
# 344| getReceiver: [SelfVariableAccess] self
|
|
# 344| getArgument: [Pair] Pair
|
|
# 344| getKey: [SymbolLiteral] :x
|
|
# 344| getComponent: [StringTextComponent] x
|
|
# 344| getValue: [LocalVariableAccess] x
|
|
# 344| getArgument: [Pair] Pair
|
|
# 344| getKey: [SymbolLiteral] :novar
|
|
# 344| getComponent: [StringTextComponent] novar
|
|
# 344| getValue: [MethodCall] call to novar
|
|
# 345| getStmt: [MethodCall] call to foo
|
|
# 345| getReceiver: [SelfVariableAccess] self
|
|
# 345| getArgument: [Pair] Pair
|
|
# 345| getKey: [SymbolLiteral] :X
|
|
# 345| getComponent: [StringTextComponent] X
|
|
# 345| getValue: [IntegerLiteral] 42
|
|
# 346| getStmt: [MethodCall] call to foo
|
|
# 346| getReceiver: [SelfVariableAccess] self
|
|
# 346| getArgument: [Pair] Pair
|
|
# 346| getKey: [SymbolLiteral] :X
|
|
# 346| getComponent: [StringTextComponent] X
|
|
# 346| getValue: [ConstantReadAccess] X
|
|
# 349| getStmt: [AssignExpr] ... = ...
|
|
# 349| getAnOperand/getLeftOperand: [LocalVariableAccess] y
|
|
# 349| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 350| getStmt: [AssignExpr] ... = ...
|
|
# 350| getAnOperand/getLeftOperand: [LocalVariableAccess] one
|
|
# 350| getAnOperand/getRightOperand: [Lambda] -> { ... }
|
|
# 350| getParameter: [SimpleParameter] x
|
|
# 350| getDefiningAccess: [LocalVariableAccess] x
|
|
# 350| getStmt: [LocalVariableAccess] y
|
|
# 351| getStmt: [AssignExpr] ... = ...
|
|
# 351| getAnOperand/getLeftOperand: [LocalVariableAccess] f
|
|
# 351| getAnOperand/getRightOperand: [Lambda] -> { ... }
|
|
# 351| getParameter: [SimpleParameter] x
|
|
# 351| getDefiningAccess: [LocalVariableAccess] x
|
|
# 351| getStmt: [MethodCall] call to foo
|
|
# 351| getReceiver: [SelfVariableAccess] self
|
|
# 351| getArgument: [LocalVariableAccess] x
|
|
# 352| getStmt: [AssignExpr] ... = ...
|
|
# 352| getAnOperand/getLeftOperand: [LocalVariableAccess] g
|
|
# 352| getAnOperand/getRightOperand: [Lambda] -> { ... }
|
|
# 352| getParameter: [SimpleParameter] x
|
|
# 352| getDefiningAccess: [LocalVariableAccess] x
|
|
# 352| getStmt: [MethodCall] call to unknown_call
|
|
# 352| getReceiver: [SelfVariableAccess] self
|
|
# 353| getStmt: [AssignExpr] ... = ...
|
|
# 353| getAnOperand/getLeftOperand: [LocalVariableAccess] h
|
|
# 353| getAnOperand/getRightOperand: [Lambda] -> { ... }
|
|
# 353| getParameter: [SimpleParameter] x
|
|
# 353| getDefiningAccess: [LocalVariableAccess] x
|
|
# 354| getStmt: [LocalVariableAccess] x
|
|
# 355| getStmt: [LocalVariableAccess] y
|
|
# 356| getStmt: [MethodCall] call to unknown_call
|
|
# 356| getReceiver: [SelfVariableAccess] self
|
|
# 360| getStmt: [MethodCall] call to empty?
|
|
# 360| getReceiver: [MethodCall] call to list
|
|
# 360| getReceiver: [SelfVariableAccess] self
|
|
# 361| getStmt: [MethodCall] call to empty?
|
|
# 361| getReceiver: [MethodCall] call to list
|
|
# 361| getReceiver: [SelfVariableAccess] self
|
|
# 362| getStmt: [MethodCall] call to empty?
|
|
# 362| getReceiver: [MethodCall] call to list
|
|
# 362| getReceiver: [SelfVariableAccess] self
|
|
# 363| getStmt: [MethodCall] call to bar
|
|
# 363| getReceiver: [MethodCall] call to foo
|
|
# 363| getReceiver: [SelfVariableAccess] self
|
|
# 363| getArgument: [IntegerLiteral] 1
|
|
# 363| getArgument: [IntegerLiteral] 2
|
|
# 363| getBlock: [BraceBlock] { ... }
|
|
# 363| getParameter: [SimpleParameter] x
|
|
# 363| getDefiningAccess: [LocalVariableAccess] x
|
|
# 363| getStmt: [LocalVariableAccess] x
|
|
control/cases.rb:
|
|
# 1| [Toplevel] cases.rb
|
|
# 2| getStmt: [AssignExpr] ... = ...
|
|
# 2| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 2| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 3| getStmt: [AssignExpr] ... = ...
|
|
# 3| getAnOperand/getLeftOperand: [LocalVariableAccess] b
|
|
# 3| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 4| getStmt: [AssignExpr] ... = ...
|
|
# 4| getAnOperand/getLeftOperand: [LocalVariableAccess] c
|
|
# 4| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 5| getStmt: [AssignExpr] ... = ...
|
|
# 5| getAnOperand/getLeftOperand: [LocalVariableAccess] d
|
|
# 5| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 8| getStmt: [CaseExpr] case ...
|
|
# 8| getValue: [LocalVariableAccess] a
|
|
# 9| getBranch: [WhenClause] when ...
|
|
# 9| getPattern: [LocalVariableAccess] b
|
|
# 9| getBody: [StmtSequence] then ...
|
|
# 10| getStmt: [IntegerLiteral] 100
|
|
# 11| getBranch: [WhenClause] when ...
|
|
# 11| getPattern: [LocalVariableAccess] c
|
|
# 11| getPattern: [LocalVariableAccess] d
|
|
# 11| getBody: [StmtSequence] then ...
|
|
# 12| getStmt: [IntegerLiteral] 200
|
|
# 13| getBranch/getElseBranch: [StmtSequence] else ...
|
|
# 14| getStmt: [IntegerLiteral] 300
|
|
# 18| getStmt: [CaseExpr] case ...
|
|
# 19| getBranch: [WhenClause] when ...
|
|
# 19| getPattern: [GTExpr] ... > ...
|
|
# 19| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 19| getAnOperand/getArgument/getLesserOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 19| getBody: [StmtSequence] then ...
|
|
# 19| getStmt: [IntegerLiteral] 10
|
|
# 20| getBranch: [WhenClause] when ...
|
|
# 20| getPattern: [EqExpr] ... == ...
|
|
# 20| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 20| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] b
|
|
# 20| getBody: [StmtSequence] then ...
|
|
# 20| getStmt: [IntegerLiteral] 20
|
|
# 21| getBranch: [WhenClause] when ...
|
|
# 21| getPattern: [LTExpr] ... < ...
|
|
# 21| getAnOperand/getLeftOperand/getLesserOperand/getReceiver: [LocalVariableAccess] a
|
|
# 21| getAnOperand/getArgument/getGreaterOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 21| getBody: [StmtSequence] then ...
|
|
# 21| getStmt: [IntegerLiteral] 30
|
|
# 26| getStmt: [CaseExpr] case ...
|
|
# 26| getValue: [MethodCall] call to expr
|
|
# 26| getReceiver: [SelfVariableAccess] self
|
|
# 27| getBranch: [InClause] in ... then ...
|
|
# 27| getPattern: [IntegerLiteral] 5
|
|
# 27| getBody: [StmtSequence] then ...
|
|
# 27| getStmt: [BooleanLiteral] true
|
|
# 28| getBranch/getElseBranch: [StmtSequence] else ...
|
|
# 28| getStmt: [BooleanLiteral] false
|
|
# 31| getStmt: [CaseExpr] case ...
|
|
# 31| getValue: [MethodCall] call to expr
|
|
# 31| getReceiver: [SelfVariableAccess] self
|
|
# 32| getBranch: [InClause] in ... then ...
|
|
# 32| getPattern: [LocalVariableAccess] x
|
|
# 32| getCondition: [LTExpr] ... < ...
|
|
# 32| getAnOperand/getLeftOperand/getLesserOperand/getReceiver: [LocalVariableAccess] x
|
|
# 32| getAnOperand/getArgument/getGreaterOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 32| getBody: [StmtSequence] then ...
|
|
# 33| getStmt: [BooleanLiteral] true
|
|
# 34| getBranch: [InClause] in ... then ...
|
|
# 34| getPattern: [LocalVariableAccess] x
|
|
# 34| getCondition: [LTExpr] ... < ...
|
|
# 34| getAnOperand/getLeftOperand/getLesserOperand/getReceiver: [LocalVariableAccess] x
|
|
# 34| getAnOperand/getArgument/getGreaterOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 34| getBody: [StmtSequence] then ...
|
|
# 35| getStmt: [BooleanLiteral] true
|
|
# 36| getBranch/getElseBranch: [StmtSequence] else ...
|
|
# 36| getStmt: [BooleanLiteral] false
|
|
# 39| getStmt: [CaseExpr] case ...
|
|
# 39| getValue: [MethodCall] call to expr
|
|
# 39| getReceiver: [SelfVariableAccess] self
|
|
# 40| getBranch: [InClause] in ... then ...
|
|
# 40| getPattern: [IntegerLiteral] 5
|
|
# 41| getBranch: [InClause] in ... then ...
|
|
# 41| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 41| getPrefixElement/getSuffixElement: [IntegerLiteral] 5
|
|
# 42| getBranch: [InClause] in ... then ...
|
|
# 42| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 42| getPrefixElement: [IntegerLiteral] 1
|
|
# 42| getPrefixElement: [IntegerLiteral] 2
|
|
# 43| getBranch: [InClause] in ... then ...
|
|
# 43| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 43| getPrefixElement/getSuffixElement: [IntegerLiteral] 1
|
|
# 43| getPrefixElement/getSuffixElement: [IntegerLiteral] 2
|
|
# 44| getBranch: [InClause] in ... then ...
|
|
# 44| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 44| getPrefixElement: [IntegerLiteral] 1
|
|
# 44| getPrefixElement: [IntegerLiteral] 2
|
|
# 44| getPrefixElement: [IntegerLiteral] 3
|
|
# 45| getBranch: [InClause] in ... then ...
|
|
# 45| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 45| getPrefixElement/getSuffixElement: [IntegerLiteral] 1
|
|
# 45| getPrefixElement/getSuffixElement: [IntegerLiteral] 2
|
|
# 45| getPrefixElement/getSuffixElement: [IntegerLiteral] 3
|
|
# 46| getBranch: [InClause] in ... then ...
|
|
# 46| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 46| getPrefixElement/getSuffixElement: [IntegerLiteral] 1
|
|
# 46| getPrefixElement/getSuffixElement: [IntegerLiteral] 2
|
|
# 46| getPrefixElement/getSuffixElement: [IntegerLiteral] 3
|
|
# 47| getBranch: [InClause] in ... then ...
|
|
# 47| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 47| getPrefixElement/getSuffixElement: [IntegerLiteral] 1
|
|
# 47| getRestVariableAccess: [LocalVariableAccess] x
|
|
# 47| getSuffixElement: [IntegerLiteral] 3
|
|
# 48| getBranch: [InClause] in ... then ...
|
|
# 48| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 49| getBranch: [InClause] in ... then ...
|
|
# 49| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 49| getSuffixElement: [IntegerLiteral] 3
|
|
# 49| getSuffixElement: [IntegerLiteral] 4
|
|
# 50| getBranch: [InClause] in ... then ...
|
|
# 50| getPattern: [FindPattern] [ *,...,* ]
|
|
# 50| getElement: [IntegerLiteral] 3
|
|
# 51| getBranch: [InClause] in ... then ...
|
|
# 51| getPattern: [FindPattern] [ *,...,* ]
|
|
# 51| getPrefixVariableAccess: [LocalVariableAccess] a
|
|
# 51| getElement: [IntegerLiteral] 3
|
|
# 51| getSuffixVariableAccess: [LocalVariableAccess] b
|
|
# 52| getBranch: [InClause] in ... then ...
|
|
# 52| getPattern: [HashPattern] { ..., ** }
|
|
# 52| getKey: [SymbolLiteral] :a
|
|
# 52| getComponent: [StringTextComponent] a
|
|
# 52| getValue: [LocalVariableAccess] a
|
|
# 53| getBranch: [InClause] in ... then ...
|
|
# 53| getPattern: [HashPattern] { ..., ** }
|
|
# 53| getKey: [SymbolLiteral] :a
|
|
# 53| getComponent: [StringTextComponent] a
|
|
# 53| getValue: [IntegerLiteral] 5
|
|
# 54| getBranch: [InClause] in ... then ...
|
|
# 54| getPattern: [HashPattern] { ..., ** }
|
|
# 54| getKey: [SymbolLiteral] :a
|
|
# 54| getComponent: [StringTextComponent] a
|
|
# 54| getValue: [IntegerLiteral] 5
|
|
# 55| getBranch: [InClause] in ... then ...
|
|
# 55| getPattern: [HashPattern] { ..., ** }
|
|
# 55| getKey: [SymbolLiteral] :a
|
|
# 55| getComponent: [StringTextComponent] a
|
|
# 55| getValue: [IntegerLiteral] 5
|
|
# 55| getKey: [SymbolLiteral] :b
|
|
# 55| getComponent: [StringTextComponent] b
|
|
# 55| getValue: [LocalVariableAccess] b
|
|
# 56| getBranch: [InClause] in ... then ...
|
|
# 56| getPattern: [HashPattern] { ..., ** }
|
|
# 56| getKey: [SymbolLiteral] :a
|
|
# 56| getComponent: [StringTextComponent] a
|
|
# 56| getValue: [IntegerLiteral] 5
|
|
# 56| getKey: [SymbolLiteral] :b
|
|
# 56| getComponent: [StringTextComponent] b
|
|
# 56| getValue: [LocalVariableAccess] b
|
|
# 56| getRestVariableAccess: [LocalVariableAccess] map
|
|
# 57| getBranch: [InClause] in ... then ...
|
|
# 57| getPattern: [HashPattern] { ..., ** }
|
|
# 57| getKey: [SymbolLiteral] :a
|
|
# 57| getComponent: [StringTextComponent] a
|
|
# 57| getValue: [IntegerLiteral] 5
|
|
# 57| getKey: [SymbolLiteral] :b
|
|
# 57| getComponent: [StringTextComponent] b
|
|
# 57| getValue: [LocalVariableAccess] b
|
|
# 58| getBranch: [InClause] in ... then ...
|
|
# 58| getPattern: [HashPattern] { ..., ** }
|
|
# 59| getBranch: [InClause] in ... then ...
|
|
# 59| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 59| getPrefixElement: [IntegerLiteral] 5
|
|
# 60| getBranch: [InClause] in ... then ...
|
|
# 60| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 60| getPrefixElement/getSuffixElement: [IntegerLiteral] 5
|
|
# 61| getBranch: [InClause] in ... then ...
|
|
# 61| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 61| getPrefixElement: [IntegerLiteral] 1
|
|
# 61| getPrefixElement: [IntegerLiteral] 2
|
|
# 62| getBranch: [InClause] in ... then ...
|
|
# 62| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 62| getPrefixElement/getSuffixElement: [IntegerLiteral] 1
|
|
# 62| getPrefixElement/getSuffixElement: [IntegerLiteral] 2
|
|
# 63| getBranch: [InClause] in ... then ...
|
|
# 63| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 63| getPrefixElement: [IntegerLiteral] 1
|
|
# 63| getPrefixElement: [IntegerLiteral] 2
|
|
# 63| getPrefixElement: [IntegerLiteral] 3
|
|
# 64| getBranch: [InClause] in ... then ...
|
|
# 64| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 64| getPrefixElement/getSuffixElement: [IntegerLiteral] 1
|
|
# 64| getPrefixElement/getSuffixElement: [IntegerLiteral] 2
|
|
# 64| getPrefixElement/getSuffixElement: [IntegerLiteral] 3
|
|
# 65| getBranch: [InClause] in ... then ...
|
|
# 65| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 65| getPrefixElement/getSuffixElement: [IntegerLiteral] 1
|
|
# 65| getPrefixElement/getSuffixElement: [IntegerLiteral] 2
|
|
# 65| getPrefixElement/getSuffixElement: [IntegerLiteral] 3
|
|
# 66| getBranch: [InClause] in ... then ...
|
|
# 66| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 66| getPrefixElement/getSuffixElement: [IntegerLiteral] 1
|
|
# 66| getRestVariableAccess: [LocalVariableAccess] x
|
|
# 66| getSuffixElement: [IntegerLiteral] 3
|
|
# 67| getBranch: [InClause] in ... then ...
|
|
# 67| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 68| getBranch: [InClause] in ... then ...
|
|
# 68| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 68| getRestVariableAccess: [LocalVariableAccess] x
|
|
# 68| getSuffixElement: [IntegerLiteral] 3
|
|
# 68| getSuffixElement: [IntegerLiteral] 4
|
|
# 69| getBranch: [InClause] in ... then ...
|
|
# 69| getPattern: [FindPattern] [ *,...,* ]
|
|
# 69| getElement: [IntegerLiteral] 3
|
|
# 70| getBranch: [InClause] in ... then ...
|
|
# 70| getPattern: [FindPattern] [ *,...,* ]
|
|
# 70| getPrefixVariableAccess: [LocalVariableAccess] a
|
|
# 70| getElement: [IntegerLiteral] 3
|
|
# 70| getSuffixVariableAccess: [LocalVariableAccess] b
|
|
# 71| getBranch: [InClause] in ... then ...
|
|
# 71| getPattern: [HashPattern] { ..., ** }
|
|
# 71| getKey: [SymbolLiteral] :a
|
|
# 71| getComponent: [StringTextComponent] a
|
|
# 71| getValue: [LocalVariableAccess] a
|
|
# 72| getBranch: [InClause] in ... then ...
|
|
# 72| getPattern: [HashPattern] { ..., ** }
|
|
# 72| getKey: [SymbolLiteral] :a
|
|
# 72| getComponent: [StringTextComponent] a
|
|
# 72| getValue: [IntegerLiteral] 5
|
|
# 73| getBranch: [InClause] in ... then ...
|
|
# 73| getPattern: [HashPattern] { ..., ** }
|
|
# 73| getKey: [SymbolLiteral] :a
|
|
# 73| getComponent: [StringTextComponent] a
|
|
# 73| getValue: [IntegerLiteral] 5
|
|
# 74| getBranch: [InClause] in ... then ...
|
|
# 74| getPattern: [HashPattern] { ..., ** }
|
|
# 74| getKey: [SymbolLiteral] :a
|
|
# 74| getComponent: [StringTextComponent] a
|
|
# 74| getValue: [IntegerLiteral] 5
|
|
# 74| getKey: [SymbolLiteral] :b
|
|
# 74| getComponent: [StringTextComponent] b
|
|
# 74| getValue: [LocalVariableAccess] b
|
|
# 75| getBranch: [InClause] in ... then ...
|
|
# 75| getPattern: [HashPattern] { ..., ** }
|
|
# 75| getKey: [SymbolLiteral] :a
|
|
# 75| getComponent: [StringTextComponent] a
|
|
# 75| getValue: [IntegerLiteral] 5
|
|
# 75| getKey: [SymbolLiteral] :b
|
|
# 75| getComponent: [StringTextComponent] b
|
|
# 75| getValue: [LocalVariableAccess] b
|
|
# 75| getRestVariableAccess: [LocalVariableAccess] map
|
|
# 76| getBranch: [InClause] in ... then ...
|
|
# 76| getPattern: [HashPattern] { ..., ** }
|
|
# 76| getKey: [SymbolLiteral] :a
|
|
# 76| getComponent: [StringTextComponent] a
|
|
# 76| getValue: [IntegerLiteral] 5
|
|
# 76| getKey: [SymbolLiteral] :b
|
|
# 76| getComponent: [StringTextComponent] b
|
|
# 76| getValue: [LocalVariableAccess] b
|
|
# 77| getBranch: [InClause] in ... then ...
|
|
# 77| getPattern: [HashPattern] { ..., ** }
|
|
# 78| getBranch: [InClause] in ... then ...
|
|
# 78| getPattern: [HashPattern] { ..., ** }
|
|
# 79| getBranch: [InClause] in ... then ...
|
|
# 79| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 84| getStmt: [AssignExpr] ... = ...
|
|
# 84| getAnOperand/getLeftOperand: [LocalVariableAccess] foo
|
|
# 84| getAnOperand/getRightOperand: [IntegerLiteral] 42
|
|
# 86| getStmt: [CaseExpr] case ...
|
|
# 86| getValue: [MethodCall] call to expr
|
|
# 86| getReceiver: [SelfVariableAccess] self
|
|
# 87| getBranch: [InClause] in ... then ...
|
|
# 87| getPattern: [IntegerLiteral] 5
|
|
# 88| getBranch: [InClause] in ... then ...
|
|
# 88| getPattern: [ReferencePattern] ^...
|
|
# 88| getExpr: [LocalVariableAccess] foo
|
|
# 89| getBranch: [InClause] in ... then ...
|
|
# 89| getPattern: [StringLiteral] "string"
|
|
# 89| getComponent: [StringTextComponent] string
|
|
# 90| getBranch: [InClause] in ... then ...
|
|
# 90| getPattern: [ArrayLiteral] %w(...)
|
|
# 90| getElement: [StringLiteral] "foo"
|
|
# 90| getComponent: [StringTextComponent] foo
|
|
# 90| getElement: [StringLiteral] "bar"
|
|
# 90| getComponent: [StringTextComponent] bar
|
|
# 91| getBranch: [InClause] in ... then ...
|
|
# 91| getPattern: [ArrayLiteral] %i(...)
|
|
# 91| getElement: [SymbolLiteral] :"foo"
|
|
# 91| getComponent: [StringTextComponent] foo
|
|
# 91| getElement: [SymbolLiteral] :"bar"
|
|
# 91| getComponent: [StringTextComponent] bar
|
|
# 92| getBranch: [InClause] in ... then ...
|
|
# 92| getPattern: [RegExpLiteral] /.*abc[0-9]/
|
|
# 92| getParsed: [RegExpSequence] .*abc[0-9]
|
|
# 92| 0: [RegExpStar] .*
|
|
# 92| 0: [RegExpDot] .
|
|
# 92| 1: [RegExpConstant, RegExpNormalChar] abc
|
|
# 92| 2: [RegExpCharacterClass] [0-9]
|
|
# 92| 0: [RegExpCharacterRange] 0-9
|
|
# 92| 0: [RegExpConstant, RegExpNormalChar] 0
|
|
# 92| 1: [RegExpConstant, RegExpNormalChar] 9
|
|
# 92| getComponent: [RegExpTextComponent] .*abc[0-9]
|
|
# 93| getBranch: [InClause] in ... then ...
|
|
# 93| getPattern: [RangeLiteral] _ .. _
|
|
# 93| getBegin: [IntegerLiteral] 5
|
|
# 93| getEnd: [IntegerLiteral] 10
|
|
# 94| getBranch: [InClause] in ... then ...
|
|
# 94| getPattern: [RangeLiteral] _ .. _
|
|
# 94| getEnd: [IntegerLiteral] 10
|
|
# 95| getBranch: [InClause] in ... then ...
|
|
# 95| getPattern: [RangeLiteral] _ .. _
|
|
# 95| getBegin: [IntegerLiteral] 5
|
|
# 96| getBranch: [InClause] in ... then ...
|
|
# 96| getPattern: [AsPattern] ... => ...
|
|
# 96| getPattern: [IntegerLiteral] 5
|
|
# 96| getVariableAccess: [LocalVariableAccess] x
|
|
# 97| getBranch: [InClause] in ... then ...
|
|
# 97| getPattern: [ConstantReadAccess] Foo
|
|
# 98| getBranch: [InClause] in ... then ...
|
|
# 98| getPattern: [ConstantReadAccess] Bar
|
|
# 98| getScopeExpr: [ConstantReadAccess] Foo
|
|
# 99| getBranch: [InClause] in ... then ...
|
|
# 99| getPattern: [ConstantReadAccess] Bar
|
|
# 99| getScopeExpr: [ConstantReadAccess] Foo
|
|
# 100| getBranch: [InClause] in ... then ...
|
|
# 100| getPattern: [AlternativePattern] ... | ...
|
|
# 100| getAlternative: [NilLiteral] nil
|
|
# 100| getAlternative: [SelfVariableAccess] self
|
|
# 100| getAlternative: [BooleanLiteral] true
|
|
# 100| getAlternative: [BooleanLiteral] false
|
|
# 100| getAlternative: [LineLiteral] __LINE__
|
|
# 100| getAlternative: [FileLiteral] __FILE__
|
|
# 100| getAlternative: [EncodingLiteral] __ENCODING__
|
|
# 101| getBranch: [InClause] in ... then ...
|
|
# 101| getPattern: [Lambda] -> { ... }
|
|
# 101| getParameter: [SimpleParameter] x
|
|
# 101| getDefiningAccess: [LocalVariableAccess] x
|
|
# 101| getStmt: [EqExpr] ... == ...
|
|
# 101| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 101| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 10
|
|
# 102| getBranch: [InClause] in ... then ...
|
|
# 102| getPattern: [SymbolLiteral] :foo
|
|
# 102| getComponent: [StringTextComponent] foo
|
|
# 103| getBranch: [InClause] in ... then ...
|
|
# 103| getPattern: [SymbolLiteral] :"foo bar"
|
|
# 103| getComponent: [StringTextComponent] foo bar
|
|
# 104| getBranch: [InClause] in ... then ...
|
|
# 104| getPattern: [AlternativePattern] ... | ...
|
|
# 104| getAlternative: [UnaryMinusExpr] - ...
|
|
# 104| getAnOperand/getOperand/getReceiver: [IntegerLiteral] 5
|
|
# 104| getAlternative: [UnaryPlusExpr] + ...
|
|
# 104| getAnOperand/getOperand/getReceiver: [IntegerLiteral] 10
|
|
# 105| getBranch: [InClause] in ... then ...
|
|
# 105| getPattern: [ParenthesizedPattern] ( ... )
|
|
# 105| getPattern: [RangeLiteral] _ .. _
|
|
# 105| getBegin: [IntegerLiteral] 1
|
|
# 106| getBranch: [InClause] in ... then ...
|
|
# 106| getPattern: [ParenthesizedPattern] ( ... )
|
|
# 106| getPattern: [AlternativePattern] ... | ...
|
|
# 106| getAlternative: [IntegerLiteral] 0
|
|
# 106| getAlternative: [StringLiteral] ""
|
|
# 106| getAlternative: [ArrayPattern] [ ..., * ]
|
|
# 106| getAlternative: [HashPattern] { ..., ** }
|
|
# 107| getBranch: [InClause] in ... then ...
|
|
# 107| getPattern: [LocalVariableAccess] var
|
|
# 110| getStmt: [CaseExpr] case ...
|
|
# 110| getValue: [MethodCall] call to expr
|
|
# 110| getReceiver: [SelfVariableAccess] self
|
|
# 111| getBranch: [InClause] in ... then ...
|
|
# 111| getPattern: [AlternativePattern] ... | ...
|
|
# 111| getAlternative: [IntegerLiteral] 5
|
|
# 111| getAlternative: [ReferencePattern] ^...
|
|
# 111| getExpr: [LocalVariableAccess] foo
|
|
# 111| getAlternative: [StringLiteral] "string"
|
|
# 111| getComponent: [StringTextComponent] string
|
|
# 111| getAlternative: [LocalVariableAccess] var
|
|
# 116| getStmt: [CaseExpr] case ...
|
|
# 116| getValue: [MethodCall] call to expr
|
|
# 116| getReceiver: [SelfVariableAccess] self
|
|
# 117| getBranch: [InClause] in ... then ...
|
|
# 117| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 118| getBranch: [InClause] in ... then ...
|
|
# 118| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 118| getPrefixElement: [LocalVariableAccess] x
|
|
# 119| getBranch: [InClause] in ... then ...
|
|
# 119| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 119| getPrefixElement/getSuffixElement: [LocalVariableAccess] x
|
|
# 120| getBranch: [InClause] in ... then ...
|
|
# 120| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 120| getClass: [ConstantReadAccess] Bar
|
|
# 120| getScopeExpr: [ConstantReadAccess] Foo
|
|
# 121| getBranch: [InClause] in ... then ...
|
|
# 121| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 121| getClass: [ConstantReadAccess] Foo
|
|
# 122| getBranch: [InClause] in ... then ...
|
|
# 122| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 122| getClass: [ConstantReadAccess] Bar
|
|
# 123| getBranch: [InClause] in ... then ...
|
|
# 123| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 123| getClass: [ConstantReadAccess] Bar
|
|
# 123| getPrefixElement/getSuffixElement: [LocalVariableAccess] a
|
|
# 123| getPrefixElement/getSuffixElement: [LocalVariableAccess] b
|
|
# 123| getRestVariableAccess: [LocalVariableAccess] c
|
|
# 123| getSuffixElement: [LocalVariableAccess] d
|
|
# 123| getSuffixElement: [LocalVariableAccess] e
|
|
# 128| getStmt: [CaseExpr] case ...
|
|
# 128| getValue: [MethodCall] call to expr
|
|
# 128| getReceiver: [SelfVariableAccess] self
|
|
# 129| getBranch: [InClause] in ... then ...
|
|
# 129| getPattern: [FindPattern] [ *,...,* ]
|
|
# 129| getElement: [LocalVariableAccess] x
|
|
# 130| getBranch: [InClause] in ... then ...
|
|
# 130| getPattern: [FindPattern] [ *,...,* ]
|
|
# 130| getPrefixVariableAccess: [LocalVariableAccess] x
|
|
# 130| getElement: [IntegerLiteral] 1
|
|
# 130| getElement: [IntegerLiteral] 2
|
|
# 130| getSuffixVariableAccess: [LocalVariableAccess] y
|
|
# 131| getBranch: [InClause] in ... then ...
|
|
# 131| getPattern: [FindPattern] [ *,...,* ]
|
|
# 131| getClass: [ConstantReadAccess] Bar
|
|
# 131| getScopeExpr: [ConstantReadAccess] Foo
|
|
# 131| getElement: [IntegerLiteral] 1
|
|
# 132| getBranch: [InClause] in ... then ...
|
|
# 132| getPattern: [FindPattern] [ *,...,* ]
|
|
# 132| getClass: [ConstantReadAccess] Foo
|
|
# 132| getElement: [ConstantReadAccess] Bar
|
|
# 137| getStmt: [CaseExpr] case ...
|
|
# 137| getValue: [MethodCall] call to expr
|
|
# 137| getReceiver: [SelfVariableAccess] self
|
|
# 138| getBranch: [InClause] in ... then ...
|
|
# 138| getPattern: [HashPattern] { ..., ** }
|
|
# 139| getBranch: [InClause] in ... then ...
|
|
# 139| getPattern: [HashPattern] { ..., ** }
|
|
# 139| getKey: [SymbolLiteral] :x
|
|
# 139| getComponent: [StringTextComponent] x
|
|
# 139| getValue: [LocalVariableAccess] x
|
|
# 140| getBranch: [InClause] in ... then ...
|
|
# 140| getPattern: [HashPattern] { ..., ** }
|
|
# 140| getClass: [ConstantReadAccess] Bar
|
|
# 140| getScopeExpr: [ConstantReadAccess] Foo
|
|
# 140| getKey: [SymbolLiteral] :x
|
|
# 140| getComponent: [StringTextComponent] x
|
|
# 140| getValue: [IntegerLiteral] 1
|
|
# 141| getBranch: [InClause] in ... then ...
|
|
# 141| getPattern: [HashPattern] { ..., ** }
|
|
# 141| getClass: [ConstantReadAccess] Bar
|
|
# 141| getScopeExpr: [ConstantReadAccess] Foo
|
|
# 141| getKey: [SymbolLiteral] :x
|
|
# 141| getComponent: [StringTextComponent] x
|
|
# 141| getValue: [IntegerLiteral] 1
|
|
# 141| getKey: [SymbolLiteral] :a
|
|
# 141| getComponent: [StringTextComponent] a
|
|
# 141| getValue: [LocalVariableAccess] a
|
|
# 141| getRestVariableAccess: [LocalVariableAccess] rest
|
|
# 142| getBranch: [InClause] in ... then ...
|
|
# 142| getPattern: [HashPattern] { ..., ** }
|
|
# 142| getClass: [ConstantReadAccess] Foo
|
|
# 142| getKey: [SymbolLiteral] :y
|
|
# 142| getComponent: [StringTextComponent] y
|
|
# 142| getValue: [LocalVariableAccess] y
|
|
# 143| getBranch: [InClause] in ... then ...
|
|
# 143| getPattern: [HashPattern] { ..., ** }
|
|
# 143| getClass: [ConstantReadAccess] Bar
|
|
# 144| getBranch: [InClause] in ... then ...
|
|
# 144| getPattern: [HashPattern] { ..., ** }
|
|
# 144| getClass: [ConstantReadAccess] Bar
|
|
# 144| getKey: [SymbolLiteral] :a
|
|
# 144| getComponent: [StringTextComponent] a
|
|
# 144| getValue: [IntegerLiteral] 1
|
|
# 147| getStmt: [CaseExpr] case ...
|
|
# 147| getValue: [MethodCall] call to expr
|
|
# 147| getReceiver: [SelfVariableAccess] self
|
|
# 148| getBranch: [InClause] in ... then ...
|
|
# 148| getPattern: [ReferencePattern] ^...
|
|
# 148| getExpr: [LocalVariableAccess] foo
|
|
# 149| getBranch: [InClause] in ... then ...
|
|
# 149| getPattern: [ReferencePattern] ^...
|
|
# 149| getExpr: [GlobalVariableAccess] $foo
|
|
# 150| getBranch: [InClause] in ... then ...
|
|
# 150| getPattern: [ReferencePattern] ^...
|
|
# 150| getExpr: [InstanceVariableAccess] @foo
|
|
# 150| getReceiver: [SelfVariableAccess] self
|
|
# 151| getBranch: [InClause] in ... then ...
|
|
# 151| getPattern: [ReferencePattern] ^...
|
|
# 151| getExpr: [ClassVariableAccess] @@foo
|
|
# 154| getStmt: [CaseExpr] case ...
|
|
# 154| getValue: [MethodCall] call to expr
|
|
# 154| getReceiver: [SelfVariableAccess] self
|
|
# 155| getBranch: [InClause] in ... then ...
|
|
# 155| getPattern: [ReferencePattern] ^...
|
|
# 155| getExpr: [LocalVariableAccess] foo
|
|
# 156| getBranch: [InClause] in ... then ...
|
|
# 156| getPattern: [ReferencePattern] ^...
|
|
# 156| getExpr: [InstanceVariableAccess] @foo
|
|
# 156| getReceiver: [SelfVariableAccess] self
|
|
# 157| getBranch: [InClause] in ... then ...
|
|
# 157| getPattern: [ReferencePattern] ^...
|
|
# 157| getExpr: [AddExpr] ... + ...
|
|
# 157| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 1
|
|
# 157| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 160| getStmt: [TestPattern] ... in ...
|
|
# 160| getValue: [MethodCall] call to expr
|
|
# 160| getReceiver: [SelfVariableAccess] self
|
|
# 160| getPattern: [ArrayPattern] [ ..., * ]
|
|
# 160| getPrefixElement: [IntegerLiteral] 1
|
|
# 160| getPrefixElement: [IntegerLiteral] 2
|
|
# 162| getStmt: [MatchPattern] ... => ...
|
|
# 162| getValue: [MethodCall] call to expr
|
|
# 162| getReceiver: [SelfVariableAccess] self
|
|
# 162| getPattern: [HashPattern] { ..., ** }
|
|
# 162| getKey: [SymbolLiteral] :x
|
|
# 162| getComponent: [StringTextComponent] x
|
|
# 162| getValue: [LocalVariableAccess] v
|
|
# 162| getKey: [SymbolLiteral] :y
|
|
# 162| getComponent: [StringTextComponent] y
|
|
# 162| getValue: [IntegerLiteral] 1
|
|
# 164| getStmt: [CaseExpr] case ...
|
|
# 165| getValue: [LocalVariableAccess] foo
|
|
# 166| getBranch: [WhenClause] when ...
|
|
# 166| getPattern: [IntegerLiteral] 1
|
|
# 166| getBody: [StmtSequence] then ...
|
|
# 166| getStmt: [IntegerLiteral] 2
|
|
# 169| getStmt: [CaseExpr] case ...
|
|
# 170| getValue: [LocalVariableAccess] foo
|
|
# 171| getBranch: [InClause] in ... then ...
|
|
# 171| getPattern: [IntegerLiteral] 3
|
|
# 171| getBody: [StmtSequence] then ...
|
|
# 171| getStmt: [StringLiteral] "three"
|
|
# 171| getComponent: [StringTextComponent] three
|
|
modules/classes.rb:
|
|
# 2| [Toplevel] classes.rb
|
|
# 3| getStmt: [ClassDeclaration] Foo
|
|
# 7| getStmt: [ClassDeclaration] Bar
|
|
# 7| getSuperclassExpr: [ConstantReadAccess] BaseClass
|
|
# 11| getStmt: [ClassDeclaration] Baz
|
|
# 11| getSuperclassExpr: [MethodCall] call to superclass_for
|
|
# 11| getReceiver: [SelfVariableAccess] self
|
|
# 11| getArgument: [SymbolLiteral] :baz
|
|
# 11| getComponent: [StringTextComponent] baz
|
|
# 15| getStmt: [ModuleDeclaration] MyModule
|
|
# 16| getStmt: [ClassDeclaration] MyClass
|
|
# 16| getScopeExpr: [ConstantReadAccess] MyModule
|
|
# 20| getStmt: [ClassDeclaration] Wibble
|
|
# 21| getStmt: [Method] method_a
|
|
# 22| getStmt: [MethodCall] call to puts
|
|
# 22| getReceiver: [SelfVariableAccess] self
|
|
# 22| getArgument: [StringLiteral] "a"
|
|
# 22| getComponent: [StringTextComponent] a
|
|
# 25| getStmt: [Method] method_b
|
|
# 26| getStmt: [MethodCall] call to puts
|
|
# 26| getReceiver: [SelfVariableAccess] self
|
|
# 26| getArgument: [StringLiteral] "b"
|
|
# 26| getComponent: [StringTextComponent] b
|
|
# 29| getStmt: [MethodCall] call to some_method_call
|
|
# 29| getReceiver: [SelfVariableAccess] self
|
|
# 30| getStmt: [AssignExpr] ... = ...
|
|
# 30| getAnOperand/getLeftOperand: [GlobalVariableAccess] $global_var
|
|
# 30| getAnOperand/getRightOperand: [IntegerLiteral] 123
|
|
# 32| getStmt: [ClassDeclaration] ClassInWibble
|
|
# 35| getStmt: [ModuleDeclaration] ModuleInWibble
|
|
# 40| getStmt: [AssignExpr] ... = ...
|
|
# 40| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 40| getAnOperand/getRightOperand: [StringLiteral] "hello"
|
|
# 40| getComponent: [StringTextComponent] hello
|
|
# 41| getStmt: [SingletonClass] class << ...
|
|
# 41| getValue: [LocalVariableAccess] x
|
|
# 42| getStmt: [Method] length
|
|
# 43| getStmt: [MulExpr] ... * ...
|
|
# 43| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 100
|
|
# 43| getAnOperand/getArgument/getRightOperand: [SuperCall] super call to length
|
|
# 46| getStmt: [Method] wibble
|
|
# 47| getStmt: [MethodCall] call to puts
|
|
# 47| getReceiver: [SelfVariableAccess] self
|
|
# 47| getArgument: [StringLiteral] "wibble"
|
|
# 47| getComponent: [StringTextComponent] wibble
|
|
# 50| getStmt: [MethodCall] call to another_method_call
|
|
# 50| getReceiver: [SelfVariableAccess] self
|
|
# 51| getStmt: [AssignExpr] ... = ...
|
|
# 51| getAnOperand/getLeftOperand: [GlobalVariableAccess] $global_var2
|
|
# 51| getAnOperand/getRightOperand: [IntegerLiteral] 456
|
|
# 55| getStmt: [ClassDeclaration] MyClassInGlobalScope
|
|
control/conditionals.rb:
|
|
# 1| [Toplevel] conditionals.rb
|
|
# 2| getStmt: [AssignExpr] ... = ...
|
|
# 2| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 2| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 3| getStmt: [AssignExpr] ... = ...
|
|
# 3| getAnOperand/getLeftOperand: [LocalVariableAccess] b
|
|
# 3| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 4| getStmt: [AssignExpr] ... = ...
|
|
# 4| getAnOperand/getLeftOperand: [LocalVariableAccess] c
|
|
# 4| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 5| getStmt: [AssignExpr] ... = ...
|
|
# 5| getAnOperand/getLeftOperand: [LocalVariableAccess] d
|
|
# 5| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 6| getStmt: [AssignExpr] ... = ...
|
|
# 6| getAnOperand/getLeftOperand: [LocalVariableAccess] e
|
|
# 6| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 7| getStmt: [AssignExpr] ... = ...
|
|
# 7| getAnOperand/getLeftOperand: [LocalVariableAccess] f
|
|
# 7| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 10| getStmt: [IfExpr] if ...
|
|
# 10| getCondition: [GTExpr] ... > ...
|
|
# 10| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 10| getAnOperand/getArgument/getLesserOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 10| getBranch/getThen: [StmtSequence] then ...
|
|
# 11| getStmt: [LocalVariableAccess] c
|
|
# 15| getStmt: [IfExpr] if ...
|
|
# 15| getCondition: [EqExpr] ... == ...
|
|
# 15| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 15| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] b
|
|
# 15| getBranch/getThen: [StmtSequence] then ...
|
|
# 16| getStmt: [LocalVariableAccess] c
|
|
# 17| getBranch/getElse: [StmtSequence] else ...
|
|
# 18| getStmt: [LocalVariableAccess] d
|
|
# 22| getStmt: [IfExpr] if ...
|
|
# 22| getCondition: [EqExpr] ... == ...
|
|
# 22| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 22| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 0
|
|
# 22| getBranch/getThen: [StmtSequence] then ...
|
|
# 23| getStmt: [LocalVariableAccess] c
|
|
# 24| getBranch/getElse: [IfExpr] elsif ...
|
|
# 24| getCondition: [EqExpr] ... == ...
|
|
# 24| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 24| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 24| getBranch/getThen: [StmtSequence] then ...
|
|
# 25| getStmt: [LocalVariableAccess] d
|
|
# 26| getBranch/getElse: [IfExpr] elsif ...
|
|
# 26| getCondition: [EqExpr] ... == ...
|
|
# 26| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 26| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 2
|
|
# 26| getBranch/getThen: [StmtSequence] then ...
|
|
# 27| getStmt: [LocalVariableAccess] e
|
|
# 28| getBranch/getElse: [StmtSequence] else ...
|
|
# 29| getStmt: [LocalVariableAccess] f
|
|
# 33| getStmt: [IfExpr] if ...
|
|
# 33| getCondition: [EqExpr] ... == ...
|
|
# 33| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 33| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 0
|
|
# 33| getBranch/getThen: [StmtSequence] then ...
|
|
# 34| getStmt: [LocalVariableAccess] b
|
|
# 35| getBranch/getElse: [IfExpr] elsif ...
|
|
# 35| getCondition: [EqExpr] ... == ...
|
|
# 35| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 35| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 35| getBranch/getThen: [StmtSequence] then ...
|
|
# 36| getStmt: [LocalVariableAccess] c
|
|
# 40| getStmt: [UnlessExpr] unless ...
|
|
# 40| getCondition: [GTExpr] ... > ...
|
|
# 40| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 40| getAnOperand/getArgument/getLesserOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 40| getBranch/getThen: [StmtSequence] then ...
|
|
# 41| getStmt: [LocalVariableAccess] c
|
|
# 45| getStmt: [UnlessExpr] unless ...
|
|
# 45| getCondition: [EqExpr] ... == ...
|
|
# 45| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 45| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] b
|
|
# 45| getBranch/getThen: [StmtSequence] then ...
|
|
# 46| getStmt: [LocalVariableAccess] c
|
|
# 47| getBranch/getElse: [StmtSequence] else ...
|
|
# 48| getStmt: [LocalVariableAccess] d
|
|
# 52| getStmt: [IfModifierExpr] ... if ...
|
|
# 52| getBody/getBranch: [AssignExpr] ... = ...
|
|
# 52| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 52| getAnOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 52| getCondition: [GTExpr] ... > ...
|
|
# 52| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] c
|
|
# 52| getAnOperand/getArgument/getLesserOperand/getRightOperand: [LocalVariableAccess] d
|
|
# 55| getStmt: [UnlessModifierExpr] ... unless ...
|
|
# 55| getBody/getBranch: [AssignExpr] ... = ...
|
|
# 55| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 55| getAnOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 55| getCondition: [LTExpr] ... < ...
|
|
# 55| getAnOperand/getLeftOperand/getLesserOperand/getReceiver: [LocalVariableAccess] c
|
|
# 55| getAnOperand/getArgument/getGreaterOperand/getRightOperand: [LocalVariableAccess] d
|
|
# 58| getStmt: [AssignExpr] ... = ...
|
|
# 58| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 58| getAnOperand/getRightOperand: [TernaryIfExpr] ... ? ... : ...
|
|
# 58| getCondition: [GTExpr] ... > ...
|
|
# 58| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] b
|
|
# 58| getAnOperand/getArgument/getLesserOperand/getRightOperand: [LocalVariableAccess] c
|
|
# 58| getBranch/getThen: [AddExpr] ... + ...
|
|
# 58| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] d
|
|
# 58| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 58| getBranch/getElse: [SubExpr] ... - ...
|
|
# 58| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] e
|
|
# 58| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 2
|
|
# 61| getStmt: [IfExpr] if ...
|
|
# 61| getCondition: [GTExpr] ... > ...
|
|
# 61| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 61| getAnOperand/getArgument/getLesserOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 61| getBranch/getThen: [StmtSequence] then ...
|
|
# 62| getStmt: [LocalVariableAccess] c
|
|
# 63| getBranch/getElse: [StmtSequence] else ...
|
|
# 67| getStmt: [IfExpr] if ...
|
|
# 67| getCondition: [GTExpr] ... > ...
|
|
# 67| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 67| getAnOperand/getArgument/getLesserOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 67| getBranch/getThen: [StmtSequence] then ...
|
|
# 68| getBranch/getElse: [StmtSequence] else ...
|
|
# 69| getStmt: [LocalVariableAccess] c
|
|
constants/constants.rb:
|
|
# 1| [Toplevel] constants.rb
|
|
# 1| getStmt: [ModuleDeclaration] ModuleA
|
|
# 2| getStmt: [ClassDeclaration] ClassA
|
|
# 3| getStmt: [AssignExpr] ... = ...
|
|
# 3| getAnOperand/getLeftOperand: [ConstantAssignment] CONST_A
|
|
# 3| getAnOperand/getRightOperand: [StringLiteral] "const_a"
|
|
# 3| getComponent: [StringTextComponent] const_a
|
|
# 6| getStmt: [AssignExpr] ... = ...
|
|
# 6| getAnOperand/getLeftOperand: [ConstantAssignment] CONST_B
|
|
# 6| getAnOperand/getRightOperand: [StringLiteral] "const_b"
|
|
# 6| getComponent: [StringTextComponent] const_b
|
|
# 8| getStmt: [ModuleDeclaration] ModuleB
|
|
# 9| getStmt: [ClassDeclaration] ClassB
|
|
# 9| getSuperclassExpr: [ConstantReadAccess] Base
|
|
# 12| getStmt: [ClassDeclaration] ClassC
|
|
# 12| getSuperclassExpr: [ConstantReadAccess] Z
|
|
# 12| getScopeExpr: [ConstantReadAccess] Y
|
|
# 12| getScopeExpr: [ConstantReadAccess] X
|
|
# 17| getStmt: [AssignExpr] ... = ...
|
|
# 17| getAnOperand/getLeftOperand: [ConstantAssignment] GREETING
|
|
# 17| getAnOperand/getRightOperand: [AddExpr] ... + ...
|
|
# 17| getAnOperand/getLeftOperand/getReceiver: [AddExpr] ... + ...
|
|
# 17| getAnOperand/getLeftOperand/getReceiver: [StringLiteral] "Hello"
|
|
# 17| getComponent: [StringTextComponent] Hello
|
|
# 17| getAnOperand/getArgument/getRightOperand: [ConstantReadAccess] CONST_A
|
|
# 17| getScopeExpr: [ConstantReadAccess] ClassA
|
|
# 17| getScopeExpr: [ConstantReadAccess] ModuleA
|
|
# 17| getAnOperand/getArgument/getRightOperand: [ConstantReadAccess] CONST_B
|
|
# 17| getScopeExpr: [ConstantReadAccess] ModuleA
|
|
# 19| getStmt: [Method] foo
|
|
# 20| getStmt: [AssignExpr] ... = ...
|
|
# 20| getAnOperand/getLeftOperand: [ConstantAssignment] Names
|
|
# 20| getAnOperand/getRightOperand: [ArrayLiteral] [...]
|
|
# 20| getElement: [StringLiteral] "Vera"
|
|
# 20| getComponent: [StringTextComponent] Vera
|
|
# 20| getElement: [StringLiteral] "Chuck"
|
|
# 20| getComponent: [StringTextComponent] Chuck
|
|
# 20| getElement: [StringLiteral] "Dave"
|
|
# 20| getComponent: [StringTextComponent] Dave
|
|
# 22| getStmt: [MethodCall] call to each
|
|
# 22| getReceiver: [ConstantReadAccess] Names
|
|
# 22| getBlock: [DoBlock] do ... end
|
|
# 22| getParameter: [SimpleParameter] name
|
|
# 22| getDefiningAccess: [LocalVariableAccess] name
|
|
# 23| getStmt: [MethodCall] call to puts
|
|
# 23| getReceiver: [SelfVariableAccess] self
|
|
# 23| getArgument: [StringLiteral] "#{...} #{...}"
|
|
# 23| getComponent: [StringInterpolationComponent] #{...}
|
|
# 23| getStmt: [ConstantReadAccess] GREETING
|
|
# 23| getComponent: [StringTextComponent]
|
|
# 23| getComponent: [StringInterpolationComponent] #{...}
|
|
# 23| getStmt: [LocalVariableAccess] name
|
|
# 28| getStmt: [MethodCall] call to Array
|
|
# 28| getReceiver: [SelfVariableAccess] self
|
|
# 28| getArgument: [StringLiteral] "foo"
|
|
# 28| getComponent: [StringTextComponent] foo
|
|
# 31| getStmt: [ClassDeclaration] ClassD
|
|
# 31| getScopeExpr: [ConstantReadAccess] ModuleA
|
|
# 31| getSuperclassExpr: [ConstantReadAccess] ClassA
|
|
# 31| getScopeExpr: [ConstantReadAccess] ModuleA
|
|
# 32| getStmt: [AssignExpr] ... = ...
|
|
# 32| getAnOperand/getLeftOperand: [ConstantAssignment] FOURTY_TWO
|
|
# 32| getAnOperand/getRightOperand: [IntegerLiteral] 42
|
|
# 35| getStmt: [ModuleDeclaration] ModuleC
|
|
# 35| getScopeExpr: [ConstantReadAccess] ModuleA
|
|
# 36| getStmt: [AssignExpr] ... = ...
|
|
# 36| getAnOperand/getLeftOperand: [ConstantAssignment] FOURTY_THREE
|
|
# 36| getAnOperand/getRightOperand: [IntegerLiteral] 43
|
|
# 39| getStmt: [AssignExpr] ... = ...
|
|
# 39| getAnOperand/getLeftOperand: [ConstantAssignment] MAX_SIZE
|
|
# 39| getScopeExpr: [ConstantReadAccess] ModuleB
|
|
# 39| getScopeExpr: [ConstantReadAccess] ModuleA
|
|
# 39| getAnOperand/getRightOperand: [IntegerLiteral] 1024
|
|
# 41| getStmt: [MethodCall] call to puts
|
|
# 41| getReceiver: [SelfVariableAccess] self
|
|
# 41| getArgument: [ConstantReadAccess] MAX_SIZE
|
|
# 41| getScopeExpr: [ConstantReadAccess] ModuleB
|
|
# 41| getScopeExpr: [ConstantReadAccess] ModuleA
|
|
# 43| getStmt: [MethodCall] call to puts
|
|
# 43| getReceiver: [SelfVariableAccess] self
|
|
# 43| getArgument: [ConstantReadAccess] GREETING
|
|
# 44| getStmt: [MethodCall] call to puts
|
|
# 44| getReceiver: [SelfVariableAccess] self
|
|
# 44| getArgument: [ConstantReadAccess] GREETING
|
|
# 46| getStmt: [ModuleDeclaration] ModuleB
|
|
# 46| getScopeExpr: [ConstantReadAccess] ModuleA
|
|
# 47| getStmt: [ClassDeclaration] ClassB
|
|
# 47| getSuperclassExpr: [ConstantReadAccess] Base
|
|
# 48| getStmt: [AssignExpr] ... = ...
|
|
# 48| getAnOperand/getLeftOperand: [ConstantAssignment] FOURTY_ONE
|
|
# 48| getAnOperand/getRightOperand: [IntegerLiteral] 41
|
|
# 52| getStmt: [ModuleDeclaration] ModuleA
|
|
# 53| getStmt: [AssignExpr] ... = ...
|
|
# 53| getAnOperand/getLeftOperand: [ConstantAssignment] FOURTY_FOUR
|
|
# 53| getAnOperand/getRightOperand: [StringLiteral] "fourty-four"
|
|
# 53| getComponent: [StringTextComponent] fourty-four
|
|
# 54| getStmt: [ClassDeclaration] ClassB
|
|
# 54| getScopeExpr: [ConstantReadAccess] ModuleB
|
|
# 54| getSuperclassExpr: [ConstantReadAccess] Base
|
|
# 55| getStmt: [AssignExpr] ... = ...
|
|
# 55| getAnOperand/getLeftOperand: [ClassVariableAccess] @@fourty_four
|
|
# 55| getAnOperand/getRightOperand: [ConstantReadAccess] FOURTY_FOUR
|
|
# 56| getStmt: [AssignExpr] ... = ...
|
|
# 56| getAnOperand/getLeftOperand: [ConstantAssignment] FOURTY_FOUR
|
|
# 56| getAnOperand/getRightOperand: [IntegerLiteral] 44
|
|
# 57| getStmt: [AssignExpr] ... = ...
|
|
# 57| getAnOperand/getLeftOperand: [ClassVariableAccess] @@fourty_four
|
|
# 57| getAnOperand/getRightOperand: [ConstantReadAccess] FOURTY_FOUR
|
|
# 61| getStmt: [ModuleDeclaration] Mod1
|
|
# 62| getStmt: [ModuleDeclaration] Mod3
|
|
# 63| getStmt: [AssignExpr] ... = ...
|
|
# 63| getAnOperand/getLeftOperand: [ConstantAssignment] FOURTY_FIVE
|
|
# 63| getAnOperand/getRightOperand: [IntegerLiteral] 45
|
|
# 65| getStmt: [AssignExpr] ... = ...
|
|
# 65| getAnOperand/getLeftOperand: [ClassVariableAccess] @@fourty_five
|
|
# 65| getAnOperand/getRightOperand: [ConstantReadAccess] FOURTY_FIVE
|
|
# 65| getScopeExpr: [ConstantReadAccess] Mod3
|
|
# 68| getStmt: [ModuleDeclaration] Mod4
|
|
# 69| getStmt: [MethodCall] call to include
|
|
# 69| getReceiver: [SelfVariableAccess] self
|
|
# 69| getArgument: [ConstantReadAccess] Mod1
|
|
# 70| getStmt: [ModuleDeclaration] Mod5
|
|
# 70| getScopeExpr: [ConstantReadAccess] Mod3
|
|
# 71| getStmt: [AssignExpr] ... = ...
|
|
# 71| getAnOperand/getLeftOperand: [ConstantAssignment] FOURTY_SIX
|
|
# 71| getAnOperand/getRightOperand: [IntegerLiteral] 46
|
|
# 73| getStmt: [AssignExpr] ... = ...
|
|
# 73| getAnOperand/getLeftOperand: [ClassVariableAccess] @@fourty_six
|
|
# 73| getAnOperand/getRightOperand: [ConstantReadAccess] FOURTY_SIX
|
|
# 73| getScopeExpr: [ConstantReadAccess] Mod3
|
|
# 78| getStmt: [AssignExpr] ... = ...
|
|
# 78| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 78| getAnOperand/getRightOperand: [ArrayLiteral] [...]
|
|
# 78| getElement: [IntegerLiteral] 1
|
|
# 78| getElement: [IntegerLiteral] 2
|
|
# 78| getElement: [IntegerLiteral] 3
|
|
# 79| getStmt: [AssignExpr] ... = ...
|
|
# 79| getAnOperand/getLeftOperand: [ConstantAssignment] A
|
|
# 79| getAnOperand/getRightOperand: [ArrayLiteral] [...]
|
|
# 79| getElement: [IntegerLiteral] 1
|
|
# 79| getElement: [IntegerLiteral] 2
|
|
# 79| getElement: [IntegerLiteral] 3
|
|
# 80| getStmt: [AssignExpr] ... = ...
|
|
# 80| getAnOperand/getLeftOperand: [ConstantAssignment] B
|
|
# 80| getAnOperand/getRightOperand: [LocalVariableAccess] a
|
|
# 81| getStmt: [AssignExpr] ... = ...
|
|
# 81| getAnOperand/getLeftOperand: [ConstantAssignment] C
|
|
# 81| getAnOperand/getRightOperand: [ConstantReadAccess] A
|
|
# 82| getStmt: [AssignExpr] ... = ...
|
|
# 82| getAnOperand/getLeftOperand: [LocalVariableAccess] b
|
|
# 82| getAnOperand/getRightOperand: [ConstantReadAccess] B
|
|
# 84| getStmt: [IfExpr] if ...
|
|
# 84| getCondition: [MethodCall] call to condition
|
|
# 84| getReceiver: [SelfVariableAccess] self
|
|
# 84| getBranch/getThen: [StmtSequence] then ...
|
|
# 85| getStmt: [AssignExpr] ... = ...
|
|
# 85| getAnOperand/getLeftOperand: [LocalVariableAccess] c
|
|
# 85| getAnOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 87| getStmt: [LocalVariableAccess] c
|
|
escape_sequences/escapes.rb:
|
|
# 1| [Toplevel] escapes.rb
|
|
# 6| getStmt: [StringLiteral] "\'"
|
|
# 6| getComponent: [StringTextComponent] \'
|
|
# 7| getStmt: [StringLiteral] "\""
|
|
# 7| getComponent: [StringTextComponent] \"
|
|
# 8| getStmt: [StringLiteral] "\\"
|
|
# 8| getComponent: [StringTextComponent] \\
|
|
# 9| getStmt: [StringLiteral] "\1"
|
|
# 9| getComponent: [StringTextComponent] \1
|
|
# 10| getStmt: [StringLiteral] "\\1"
|
|
# 10| getComponent: [StringTextComponent] \\1
|
|
# 11| getStmt: [StringLiteral] "\141"
|
|
# 11| getComponent: [StringTextComponent] \141
|
|
# 12| getStmt: [StringLiteral] "\n"
|
|
# 12| getComponent: [StringTextComponent] \n
|
|
# 15| getStmt: [StringLiteral] "\'"
|
|
# 15| getComponent: [StringEscapeSequenceComponent] \'
|
|
# 16| getStmt: [StringLiteral] "\""
|
|
# 16| getComponent: [StringEscapeSequenceComponent] \"
|
|
# 17| getStmt: [StringLiteral] "\\"
|
|
# 17| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 18| getStmt: [StringLiteral] "\1"
|
|
# 18| getComponent: [StringEscapeSequenceComponent] \1
|
|
# 19| getStmt: [StringLiteral] "\\1"
|
|
# 19| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 19| getComponent: [StringTextComponent] 1
|
|
# 20| getStmt: [StringLiteral] "\141"
|
|
# 20| getComponent: [StringEscapeSequenceComponent] \141
|
|
# 21| getStmt: [StringLiteral] "\x6d"
|
|
# 21| getComponent: [StringEscapeSequenceComponent] \x6d
|
|
# 22| getStmt: [StringLiteral] "\x6E"
|
|
# 22| getComponent: [StringEscapeSequenceComponent] \x6E
|
|
# 23| getStmt: [StringLiteral] "\X6d"
|
|
# 23| getComponent: [StringEscapeSequenceComponent] \X
|
|
# 23| getComponent: [StringTextComponent] 6d
|
|
# 24| getStmt: [StringLiteral] "\X6E"
|
|
# 24| getComponent: [StringEscapeSequenceComponent] \X
|
|
# 24| getComponent: [StringTextComponent] 6E
|
|
# 25| getStmt: [StringLiteral] "\u203d"
|
|
# 25| getComponent: [StringEscapeSequenceComponent] \u203d
|
|
# 26| getStmt: [StringLiteral] "\u{62}"
|
|
# 26| getComponent: [StringEscapeSequenceComponent] \u{62}
|
|
# 27| getStmt: [StringLiteral] "\u{1f60a}"
|
|
# 27| getComponent: [StringEscapeSequenceComponent] \u{1f60a}
|
|
# 28| getStmt: [StringLiteral] "\a"
|
|
# 28| getComponent: [StringEscapeSequenceComponent] \a
|
|
# 29| getStmt: [StringLiteral] "\b"
|
|
# 29| getComponent: [StringEscapeSequenceComponent] \b
|
|
# 30| getStmt: [StringLiteral] "\t"
|
|
# 30| getComponent: [StringEscapeSequenceComponent] \t
|
|
# 31| getStmt: [StringLiteral] "\n"
|
|
# 31| getComponent: [StringEscapeSequenceComponent] \n
|
|
# 32| getStmt: [StringLiteral] "\v"
|
|
# 32| getComponent: [StringEscapeSequenceComponent] \v
|
|
# 33| getStmt: [StringLiteral] "\f"
|
|
# 33| getComponent: [StringEscapeSequenceComponent] \f
|
|
# 34| getStmt: [StringLiteral] "\r"
|
|
# 34| getComponent: [StringEscapeSequenceComponent] \r
|
|
# 35| getStmt: [StringLiteral] "\e"
|
|
# 35| getComponent: [StringEscapeSequenceComponent] \e
|
|
# 36| getStmt: [StringLiteral] "\s"
|
|
# 36| getComponent: [StringEscapeSequenceComponent] \s
|
|
# 37| getStmt: [StringLiteral] "\c?"
|
|
# 37| getComponent: [StringEscapeSequenceComponent] \c
|
|
# 37| getComponent: [StringTextComponent] ?
|
|
# 38| getStmt: [StringLiteral] "\C-?"
|
|
# 38| getComponent: [StringEscapeSequenceComponent] \C
|
|
# 38| getComponent: [StringTextComponent] -?
|
|
# 43| getStmt: [AssignExpr] ... = ...
|
|
# 43| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 43| getAnOperand/getRightOperand: [StringLiteral] "\\."
|
|
# 43| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 43| getComponent: [StringTextComponent] .
|
|
# 44| getStmt: [StringLiteral] "#{...}"
|
|
# 44| getComponent: [StringInterpolationComponent] #{...}
|
|
# 44| getStmt: [LocalVariableAccess] a
|
|
# 48| getStmt: [RegExpLiteral] /\n/
|
|
# 48| getParsed: [RegExpConstant, RegExpEscape] \n
|
|
# 48| getComponent: [RegExpEscapeSequenceComponent] \n
|
|
# 49| getStmt: [RegExpLiteral] /\p/
|
|
# 49| getParsed: [RegExpConstant, RegExpEscape] \p
|
|
# 49| getComponent: [RegExpEscapeSequenceComponent] \p
|
|
# 50| getStmt: [RegExpLiteral] /\u0061/
|
|
# 50| getParsed: [RegExpConstant, RegExpEscape] \u0061
|
|
# 50| getComponent: [RegExpEscapeSequenceComponent] \u0061
|
|
# 53| getStmt: [AssignExpr] ... = ...
|
|
# 53| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 53| getAnOperand/getRightOperand: [StringLiteral] "\\."
|
|
# 53| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 53| getComponent: [StringTextComponent] .
|
|
# 54| getStmt: [AssignExpr] ... = ...
|
|
# 54| getAnOperand/getLeftOperand: [LocalVariableAccess] b
|
|
# 54| getAnOperand/getRightOperand: [RegExpLiteral] /\./
|
|
# 54| getParsed: [RegExpConstant, RegExpEscape] \.
|
|
# 54| getComponent: [RegExpEscapeSequenceComponent] \.
|
|
# 55| getStmt: [RegExpLiteral] /#{...}#{...}/
|
|
# 55| getParsed: [RegExpSequence] \.\.
|
|
# 55| 0: [RegExpConstant, RegExpEscape] \.
|
|
# 55| 1: [RegExpConstant, RegExpEscape] \.
|
|
# 55| getComponent: [RegExpInterpolationComponent] #{...}
|
|
# 55| getStmt: [LocalVariableAccess] a
|
|
# 55| getComponent: [RegExpInterpolationComponent] #{...}
|
|
# 55| getStmt: [LocalVariableAccess] b
|
|
# 58| getStmt: [ArrayLiteral] %w(...)
|
|
# 58| getElement: [StringLiteral] "foo \n"
|
|
# 58| getComponent: [StringTextComponent] foo
|
|
# 58| getComponent: [StringEscapeSequenceComponent] \n
|
|
# 58| getElement: [StringLiteral] "bar"
|
|
# 58| getComponent: [StringTextComponent] bar
|
|
# 61| getStmt: [SymbolLiteral] :"\'"
|
|
# 61| getComponent: [StringTextComponent] \'
|
|
# 62| getStmt: [SymbolLiteral] :"\""
|
|
# 62| getComponent: [StringTextComponent] \"
|
|
# 63| getStmt: [SymbolLiteral] :"\\"
|
|
# 63| getComponent: [StringTextComponent] \\
|
|
# 64| getStmt: [SymbolLiteral] :"\1"
|
|
# 64| getComponent: [StringTextComponent] \1
|
|
# 65| getStmt: [SymbolLiteral] :"\\1"
|
|
# 65| getComponent: [StringTextComponent] \\1
|
|
# 66| getStmt: [SymbolLiteral] :"\141"
|
|
# 66| getComponent: [StringTextComponent] \141
|
|
# 67| getStmt: [SymbolLiteral] :"\n"
|
|
# 67| getComponent: [StringTextComponent] \n
|
|
# 70| getStmt: [SymbolLiteral] :"\'"
|
|
# 70| getComponent: [StringEscapeSequenceComponent] \'
|
|
# 71| getStmt: [SymbolLiteral] :"\""
|
|
# 71| getComponent: [StringEscapeSequenceComponent] \"
|
|
# 72| getStmt: [SymbolLiteral] :"\\"
|
|
# 72| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 73| getStmt: [SymbolLiteral] :"\1"
|
|
# 73| getComponent: [StringEscapeSequenceComponent] \1
|
|
# 74| getStmt: [SymbolLiteral] :"\\1"
|
|
# 74| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 74| getComponent: [StringTextComponent] 1
|
|
# 75| getStmt: [SymbolLiteral] :"\141"
|
|
# 75| getComponent: [StringEscapeSequenceComponent] \141
|
|
# 76| getStmt: [SymbolLiteral] :"\x6d"
|
|
# 76| getComponent: [StringEscapeSequenceComponent] \x6d
|
|
# 77| getStmt: [SymbolLiteral] :"\x6E"
|
|
# 77| getComponent: [StringEscapeSequenceComponent] \x6E
|
|
# 78| getStmt: [SymbolLiteral] :"\X6d"
|
|
# 78| getComponent: [StringEscapeSequenceComponent] \X
|
|
# 78| getComponent: [StringTextComponent] 6d
|
|
# 79| getStmt: [SymbolLiteral] :"\X6E"
|
|
# 79| getComponent: [StringEscapeSequenceComponent] \X
|
|
# 79| getComponent: [StringTextComponent] 6E
|
|
# 80| getStmt: [SymbolLiteral] :"\u203d"
|
|
# 80| getComponent: [StringEscapeSequenceComponent] \u203d
|
|
# 81| getStmt: [SymbolLiteral] :"\u{62}"
|
|
# 81| getComponent: [StringEscapeSequenceComponent] \u{62}
|
|
# 82| getStmt: [SymbolLiteral] :"\u{1f60a}"
|
|
# 82| getComponent: [StringEscapeSequenceComponent] \u{1f60a}
|
|
# 83| getStmt: [SymbolLiteral] :"\a"
|
|
# 83| getComponent: [StringEscapeSequenceComponent] \a
|
|
# 84| getStmt: [SymbolLiteral] :"\b"
|
|
# 84| getComponent: [StringEscapeSequenceComponent] \b
|
|
# 85| getStmt: [SymbolLiteral] :"\t"
|
|
# 85| getComponent: [StringEscapeSequenceComponent] \t
|
|
# 86| getStmt: [SymbolLiteral] :"\n"
|
|
# 86| getComponent: [StringEscapeSequenceComponent] \n
|
|
# 87| getStmt: [SymbolLiteral] :"\v"
|
|
# 87| getComponent: [StringEscapeSequenceComponent] \v
|
|
# 88| getStmt: [SymbolLiteral] :"\f"
|
|
# 88| getComponent: [StringEscapeSequenceComponent] \f
|
|
# 89| getStmt: [SymbolLiteral] :"\r"
|
|
# 89| getComponent: [StringEscapeSequenceComponent] \r
|
|
# 90| getStmt: [SymbolLiteral] :"\e"
|
|
# 90| getComponent: [StringEscapeSequenceComponent] \e
|
|
# 91| getStmt: [SymbolLiteral] :"\s"
|
|
# 91| getComponent: [StringEscapeSequenceComponent] \s
|
|
# 92| getStmt: [SymbolLiteral] :"\c?"
|
|
# 92| getComponent: [StringEscapeSequenceComponent] \c
|
|
# 92| getComponent: [StringTextComponent] ?
|
|
# 93| getStmt: [SymbolLiteral] :"\C-?"
|
|
# 93| getComponent: [StringEscapeSequenceComponent] \C
|
|
# 93| getComponent: [StringTextComponent] -?
|
|
misc/iso-8859-15.rb:
|
|
# 1| [Toplevel] iso-8859-15.rb
|
|
# 4| getStmt: [MethodCall] call to print
|
|
# 4| getReceiver: [SelfVariableAccess] self
|
|
# 4| getArgument: [StringLiteral] "EUR = €"
|
|
# 4| getComponent: [StringTextComponent] EUR = €
|
|
literals/literals.rb:
|
|
# 1| [Toplevel] literals.rb
|
|
# 2| getStmt: [NilLiteral] nil
|
|
# 3| getStmt: [ConstantReadAccess] NIL
|
|
# 4| getStmt: [BooleanLiteral] false
|
|
# 5| getStmt: [ConstantReadAccess] FALSE
|
|
# 6| getStmt: [BooleanLiteral] true
|
|
# 7| getStmt: [ConstantReadAccess] TRUE
|
|
# 10| getStmt: [IntegerLiteral] 1234
|
|
# 11| getStmt: [IntegerLiteral] 5_678
|
|
# 12| getStmt: [IntegerLiteral] 0
|
|
# 13| getStmt: [IntegerLiteral] 0d900
|
|
# 14| getStmt: [IntegerLiteral] 2147483647
|
|
# 15| getStmt: [IntegerLiteral] 2147483648
|
|
# 18| getStmt: [IntegerLiteral] 0x1234
|
|
# 19| getStmt: [IntegerLiteral] 0xbeef
|
|
# 20| getStmt: [IntegerLiteral] 0xF0_0D
|
|
# 21| getStmt: [IntegerLiteral] 0x000000000000000000ff
|
|
# 22| getStmt: [IntegerLiteral] 0x7FFF_FFFF
|
|
# 23| getStmt: [IntegerLiteral] 0x80000000
|
|
# 24| getStmt: [IntegerLiteral] 0xdeadbeef
|
|
# 25| getStmt: [IntegerLiteral] 0xF00D_face
|
|
# 28| getStmt: [IntegerLiteral] 0123
|
|
# 29| getStmt: [IntegerLiteral] 0o234
|
|
# 30| getStmt: [IntegerLiteral] 0O45_6
|
|
# 31| getStmt: [IntegerLiteral] 0000000000000000000000000000010
|
|
# 32| getStmt: [IntegerLiteral] 017777777777
|
|
# 33| getStmt: [IntegerLiteral] 020000000000
|
|
# 36| getStmt: [IntegerLiteral] 0b10010100
|
|
# 37| getStmt: [IntegerLiteral] 0B011_01101
|
|
# 38| getStmt: [IntegerLiteral] 0b00000000000000000000000000000000000000011
|
|
# 39| getStmt: [IntegerLiteral] 0b01111111111111111111111111111111
|
|
# 40| getStmt: [IntegerLiteral] 0b10000000000000000000000000000000
|
|
# 43| getStmt: [FloatLiteral] 12.34
|
|
# 44| getStmt: [FloatLiteral] 1234e-2
|
|
# 45| getStmt: [FloatLiteral] 1.234E1
|
|
# 48| getStmt: [RationalLiteral] 23r
|
|
# 49| getStmt: [RationalLiteral] 9.85r
|
|
# 52| getStmt: [ComplexLiteral] 2i
|
|
# 53| getStmt: [ComplexLiteral] 3.14i
|
|
# 56| getStmt: [ComplexLiteral] 1.2ri
|
|
# 59| getStmt: [StringLiteral] ""
|
|
# 60| getStmt: [StringLiteral] ""
|
|
# 61| getStmt: [StringLiteral] "hello"
|
|
# 61| getComponent: [StringTextComponent] hello
|
|
# 62| getStmt: [StringLiteral] "goodbye"
|
|
# 62| getComponent: [StringTextComponent] goodbye
|
|
# 63| getStmt: [StringLiteral] "string with escaped \" quote"
|
|
# 63| getComponent: [StringTextComponent] string with escaped
|
|
# 63| getComponent: [StringEscapeSequenceComponent] \"
|
|
# 63| getComponent: [StringTextComponent] quote
|
|
# 64| getStmt: [StringLiteral] "string with " quote"
|
|
# 64| getComponent: [StringTextComponent] string with " quote
|
|
# 65| getStmt: [StringLiteral] "foo bar baz"
|
|
# 65| getComponent: [StringTextComponent] foo bar baz
|
|
# 66| getStmt: [StringLiteral] "foo bar baz"
|
|
# 66| getComponent: [StringTextComponent] foo bar baz
|
|
# 67| getStmt: [StringLiteral] "foo ' bar " baz'"
|
|
# 67| getComponent: [StringTextComponent] foo ' bar " baz'
|
|
# 68| getStmt: [StringLiteral] "FOO ' BAR " BAZ'"
|
|
# 68| getComponent: [StringTextComponent] FOO ' BAR " BAZ'
|
|
# 69| getStmt: [StringLiteral] "foo\ bar"
|
|
# 69| getComponent: [StringTextComponent] foo\ bar
|
|
# 70| getStmt: [StringLiteral] "foo\ bar"
|
|
# 70| getComponent: [StringTextComponent] foo
|
|
# 70| getComponent: [StringEscapeSequenceComponent] \
|
|
# 70| getComponent: [StringTextComponent] bar
|
|
# 71| getStmt: [StringLiteral] "2 + 2 = #{...}"
|
|
# 71| getComponent: [StringTextComponent] 2 + 2 =
|
|
# 71| getComponent: [StringInterpolationComponent] #{...}
|
|
# 71| getStmt: [AddExpr] ... + ...
|
|
# 71| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 2
|
|
# 71| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 2
|
|
# 72| getStmt: [StringLiteral] "3 + 4 = #{...}"
|
|
# 72| getComponent: [StringTextComponent] 3 + 4 =
|
|
# 72| getComponent: [StringInterpolationComponent] #{...}
|
|
# 72| getStmt: [AddExpr] ... + ...
|
|
# 72| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 3
|
|
# 72| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 4
|
|
# 73| getStmt: [StringLiteral] "2 + 2 = #{ 2 + 2 }"
|
|
# 73| getComponent: [StringTextComponent] 2 + 2 = #{ 2 + 2 }
|
|
# 74| getStmt: [StringLiteral] "3 + 4 = #{ 3 + 4 }"
|
|
# 74| getComponent: [StringTextComponent] 3 + 4 = #{ 3 + 4 }
|
|
# 75| getStmt: [StringConcatenation] "..." "..."
|
|
# 75| getString: [StringLiteral] "foo"
|
|
# 75| getComponent: [StringTextComponent] foo
|
|
# 75| getString: [StringLiteral] "bar"
|
|
# 75| getComponent: [StringTextComponent] bar
|
|
# 75| getString: [StringLiteral] "baz"
|
|
# 75| getComponent: [StringTextComponent] baz
|
|
# 76| getStmt: [StringConcatenation] "..." "..."
|
|
# 76| getString: [StringLiteral] "foo"
|
|
# 76| getComponent: [StringTextComponent] foo
|
|
# 76| getString: [StringLiteral] "bar"
|
|
# 76| getComponent: [StringTextComponent] bar
|
|
# 76| getString: [StringLiteral] "baz"
|
|
# 76| getComponent: [StringTextComponent] baz
|
|
# 77| getStmt: [StringConcatenation] "..." "..."
|
|
# 77| getString: [StringLiteral] "foo"
|
|
# 77| getComponent: [StringTextComponent] foo
|
|
# 77| getString: [StringLiteral] "bar#{...}"
|
|
# 77| getComponent: [StringTextComponent] bar
|
|
# 77| getComponent: [StringInterpolationComponent] #{...}
|
|
# 77| getStmt: [MulExpr] ... * ...
|
|
# 77| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 1
|
|
# 77| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 77| getString: [StringLiteral] "baz"
|
|
# 77| getComponent: [StringTextComponent] baz
|
|
# 78| getStmt: [StringLiteral] "foo #{...} qux"
|
|
# 78| getComponent: [StringTextComponent] foo
|
|
# 78| getComponent: [StringInterpolationComponent] #{...}
|
|
# 78| getStmt: [StringLiteral] "bar #{...} baz"
|
|
# 78| getComponent: [StringTextComponent] bar
|
|
# 78| getComponent: [StringInterpolationComponent] #{...}
|
|
# 78| getStmt: [AddExpr] ... + ...
|
|
# 78| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 2
|
|
# 78| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 3
|
|
# 78| getComponent: [StringTextComponent] baz
|
|
# 78| getComponent: [StringTextComponent] qux
|
|
# 79| getStmt: [StringLiteral] "foo #{...}"
|
|
# 79| getComponent: [StringTextComponent] foo
|
|
# 79| getComponent: [StringInterpolationComponent] #{...}
|
|
# 79| getStmt: [MethodCall] call to blah
|
|
# 79| getReceiver: [SelfVariableAccess] self
|
|
# 79| getStmt: [AddExpr] ... + ...
|
|
# 79| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 1
|
|
# 79| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 9
|
|
# 80| getStmt: [AssignExpr] ... = ...
|
|
# 80| getAnOperand/getLeftOperand: [LocalVariableAccess] bar
|
|
# 80| getAnOperand/getRightOperand: [StringLiteral] "bar"
|
|
# 80| getComponent: [StringTextComponent] bar
|
|
# 81| getStmt: [AssignExpr] ... = ...
|
|
# 81| getAnOperand/getLeftOperand: [ConstantAssignment] BAR
|
|
# 81| getAnOperand/getRightOperand: [StringLiteral] "bar"
|
|
# 81| getComponent: [StringTextComponent] bar
|
|
# 82| getStmt: [StringLiteral] "foo #{...}"
|
|
# 82| getComponent: [StringTextComponent] foo
|
|
# 82| getComponent: [StringInterpolationComponent] #{...}
|
|
# 82| getStmt: [LocalVariableAccess] bar
|
|
# 83| getStmt: [StringLiteral] "foo #{...}"
|
|
# 83| getComponent: [StringTextComponent] foo
|
|
# 83| getComponent: [StringInterpolationComponent] #{...}
|
|
# 83| getStmt: [ConstantReadAccess] BAR
|
|
# 86| getStmt: [CharacterLiteral] ?x
|
|
# 87| getStmt: [CharacterLiteral] ?\n
|
|
# 88| getStmt: [CharacterLiteral] ?\s
|
|
# 89| getStmt: [CharacterLiteral] ?\\
|
|
# 90| getStmt: [CharacterLiteral] ?\u{58}
|
|
# 91| getStmt: [CharacterLiteral] ?\C-a
|
|
# 92| getStmt: [CharacterLiteral] ?\M-a
|
|
# 93| getStmt: [CharacterLiteral] ?\M-\C-a
|
|
# 94| getStmt: [CharacterLiteral] ?\C-\M-a
|
|
# 97| getStmt: [SymbolLiteral] :""
|
|
# 98| getStmt: [SymbolLiteral] :hello
|
|
# 98| getComponent: [StringTextComponent] hello
|
|
# 99| getStmt: [SymbolLiteral] :"foo bar"
|
|
# 99| getComponent: [StringTextComponent] foo bar
|
|
# 100| getStmt: [SymbolLiteral] :"bar baz"
|
|
# 100| getComponent: [StringTextComponent] bar baz
|
|
# 101| getStmt: [HashLiteral] {...}
|
|
# 101| getElement: [Pair] Pair
|
|
# 101| getKey: [SymbolLiteral] :foo
|
|
# 101| getComponent: [StringTextComponent] foo
|
|
# 101| getValue: [StringLiteral] "bar"
|
|
# 101| getComponent: [StringTextComponent] bar
|
|
# 102| getStmt: [SymbolLiteral] :"wibble"
|
|
# 102| getComponent: [StringTextComponent] wibble
|
|
# 103| getStmt: [SymbolLiteral] :"wibble wobble"
|
|
# 103| getComponent: [StringTextComponent] wibble wobble
|
|
# 104| getStmt: [SymbolLiteral] :"foo_#{...}_#{...}_#{...}"
|
|
# 104| getComponent: [StringTextComponent] foo_
|
|
# 104| getComponent: [StringInterpolationComponent] #{...}
|
|
# 104| getStmt: [AddExpr] ... + ...
|
|
# 104| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 2
|
|
# 104| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 2
|
|
# 104| getComponent: [StringTextComponent] _
|
|
# 104| getComponent: [StringInterpolationComponent] #{...}
|
|
# 104| getStmt: [LocalVariableAccess] bar
|
|
# 104| getComponent: [StringTextComponent] _
|
|
# 104| getComponent: [StringInterpolationComponent] #{...}
|
|
# 104| getStmt: [ConstantReadAccess] BAR
|
|
# 105| getStmt: [SymbolLiteral] :"foo_#{ 2 + 2}_#{bar}_#{BAR}"
|
|
# 105| getComponent: [StringTextComponent] foo_#{ 2 + 2}_#{bar}_#{BAR}
|
|
# 106| getStmt: [SymbolLiteral] :"foo_#{ 3 - 2 }"
|
|
# 106| getComponent: [StringTextComponent] foo_#{ 3 - 2 }
|
|
# 109| getStmt: [ArrayLiteral] [...]
|
|
# 110| getStmt: [ArrayLiteral] [...]
|
|
# 110| getElement: [IntegerLiteral] 1
|
|
# 110| getElement: [IntegerLiteral] 2
|
|
# 110| getElement: [IntegerLiteral] 3
|
|
# 111| getStmt: [ArrayLiteral] [...]
|
|
# 111| getElement: [IntegerLiteral] 4
|
|
# 111| getElement: [IntegerLiteral] 5
|
|
# 111| getElement: [DivExpr] ... / ...
|
|
# 111| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 12
|
|
# 111| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 2
|
|
# 112| getStmt: [ArrayLiteral] [...]
|
|
# 112| getElement: [IntegerLiteral] 7
|
|
# 112| getElement: [ArrayLiteral] [...]
|
|
# 112| getElement: [IntegerLiteral] 8
|
|
# 112| getElement: [IntegerLiteral] 9
|
|
# 115| getStmt: [ArrayLiteral] %w(...)
|
|
# 116| getStmt: [ArrayLiteral] %w(...)
|
|
# 116| getElement: [StringLiteral] "foo"
|
|
# 116| getComponent: [StringTextComponent] foo
|
|
# 116| getElement: [StringLiteral] "bar"
|
|
# 116| getComponent: [StringTextComponent] bar
|
|
# 116| getElement: [StringLiteral] "baz"
|
|
# 116| getComponent: [StringTextComponent] baz
|
|
# 117| getStmt: [ArrayLiteral] %w(...)
|
|
# 117| getElement: [StringLiteral] "foo"
|
|
# 117| getComponent: [StringTextComponent] foo
|
|
# 117| getElement: [StringLiteral] "bar"
|
|
# 117| getComponent: [StringTextComponent] bar
|
|
# 117| getElement: [StringLiteral] "baz"
|
|
# 117| getComponent: [StringTextComponent] baz
|
|
# 118| getStmt: [ArrayLiteral] %w(...)
|
|
# 118| getElement: [StringLiteral] "foo"
|
|
# 118| getComponent: [StringTextComponent] foo
|
|
# 118| getElement: [StringLiteral] "bar#{...}"
|
|
# 118| getComponent: [StringTextComponent] bar
|
|
# 118| getComponent: [StringInterpolationComponent] #{...}
|
|
# 118| getStmt: [AddExpr] ... + ...
|
|
# 118| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 1
|
|
# 118| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 118| getElement: [StringLiteral] "#{...}"
|
|
# 118| getComponent: [StringInterpolationComponent] #{...}
|
|
# 118| getStmt: [LocalVariableAccess] bar
|
|
# 118| getElement: [StringLiteral] "#{...}"
|
|
# 118| getComponent: [StringInterpolationComponent] #{...}
|
|
# 118| getStmt: [ConstantReadAccess] BAR
|
|
# 118| getElement: [StringLiteral] "baz"
|
|
# 118| getComponent: [StringTextComponent] baz
|
|
# 119| getStmt: [ArrayLiteral] %w(...)
|
|
# 119| getElement: [StringLiteral] "foo"
|
|
# 119| getComponent: [StringTextComponent] foo
|
|
# 119| getElement: [StringLiteral] "bar#{1+1}"
|
|
# 119| getComponent: [StringTextComponent] bar#{1+1}
|
|
# 119| getElement: [StringLiteral] "#{bar}"
|
|
# 119| getComponent: [StringTextComponent] #{bar}
|
|
# 119| getElement: [StringLiteral] "#{BAR}"
|
|
# 119| getComponent: [StringTextComponent] #{BAR}
|
|
# 119| getElement: [StringLiteral] "baz"
|
|
# 119| getComponent: [StringTextComponent] baz
|
|
# 122| getStmt: [ArrayLiteral] %i(...)
|
|
# 123| getStmt: [ArrayLiteral] %i(...)
|
|
# 123| getElement: [SymbolLiteral] :"foo"
|
|
# 123| getComponent: [StringTextComponent] foo
|
|
# 123| getElement: [SymbolLiteral] :"bar"
|
|
# 123| getComponent: [StringTextComponent] bar
|
|
# 123| getElement: [SymbolLiteral] :"baz"
|
|
# 123| getComponent: [StringTextComponent] baz
|
|
# 124| getStmt: [ArrayLiteral] %i(...)
|
|
# 124| getElement: [SymbolLiteral] :"foo"
|
|
# 124| getComponent: [StringTextComponent] foo
|
|
# 124| getElement: [SymbolLiteral] :"bar"
|
|
# 124| getComponent: [StringTextComponent] bar
|
|
# 124| getElement: [SymbolLiteral] :"baz"
|
|
# 124| getComponent: [StringTextComponent] baz
|
|
# 125| getStmt: [ArrayLiteral] %i(...)
|
|
# 125| getElement: [SymbolLiteral] :"foo"
|
|
# 125| getComponent: [StringTextComponent] foo
|
|
# 125| getElement: [SymbolLiteral] :"bar#{...}"
|
|
# 125| getComponent: [StringTextComponent] bar
|
|
# 125| getComponent: [StringInterpolationComponent] #{...}
|
|
# 125| getStmt: [AddExpr] ... + ...
|
|
# 125| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 2
|
|
# 125| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 4
|
|
# 125| getElement: [SymbolLiteral] :"#{...}"
|
|
# 125| getComponent: [StringInterpolationComponent] #{...}
|
|
# 125| getStmt: [LocalVariableAccess] bar
|
|
# 125| getElement: [SymbolLiteral] :"#{...}"
|
|
# 125| getComponent: [StringInterpolationComponent] #{...}
|
|
# 125| getStmt: [ConstantReadAccess] BAR
|
|
# 125| getElement: [SymbolLiteral] :"baz"
|
|
# 125| getComponent: [StringTextComponent] baz
|
|
# 126| getStmt: [ArrayLiteral] %i(...)
|
|
# 126| getElement: [SymbolLiteral] :"foo"
|
|
# 126| getComponent: [StringTextComponent] foo
|
|
# 126| getElement: [SymbolLiteral] :"bar#{"
|
|
# 126| getComponent: [StringTextComponent] bar#{
|
|
# 126| getElement: [SymbolLiteral] :"2"
|
|
# 126| getComponent: [StringTextComponent] 2
|
|
# 126| getElement: [SymbolLiteral] :"+"
|
|
# 126| getComponent: [StringTextComponent] +
|
|
# 126| getElement: [SymbolLiteral] :"4"
|
|
# 126| getComponent: [StringTextComponent] 4
|
|
# 126| getElement: [SymbolLiteral] :"}"
|
|
# 126| getComponent: [StringTextComponent] }
|
|
# 126| getElement: [SymbolLiteral] :"#{bar}"
|
|
# 126| getComponent: [StringTextComponent] #{bar}
|
|
# 126| getElement: [SymbolLiteral] :"#{BAR}"
|
|
# 126| getComponent: [StringTextComponent] #{BAR}
|
|
# 126| getElement: [SymbolLiteral] :"baz"
|
|
# 126| getComponent: [StringTextComponent] baz
|
|
# 129| getStmt: [HashLiteral] {...}
|
|
# 130| getStmt: [HashLiteral] {...}
|
|
# 130| getElement: [Pair] Pair
|
|
# 130| getKey: [SymbolLiteral] :foo
|
|
# 130| getComponent: [StringTextComponent] foo
|
|
# 130| getValue: [IntegerLiteral] 1
|
|
# 130| getElement: [Pair] Pair
|
|
# 130| getKey: [SymbolLiteral] :bar
|
|
# 130| getComponent: [StringTextComponent] bar
|
|
# 130| getValue: [IntegerLiteral] 2
|
|
# 130| getElement: [Pair] Pair
|
|
# 130| getKey: [StringLiteral] "baz"
|
|
# 130| getComponent: [StringTextComponent] baz
|
|
# 130| getValue: [IntegerLiteral] 3
|
|
# 131| getStmt: [HashLiteral] {...}
|
|
# 131| getElement: [Pair] Pair
|
|
# 131| getKey: [SymbolLiteral] :foo
|
|
# 131| getComponent: [StringTextComponent] foo
|
|
# 131| getValue: [IntegerLiteral] 7
|
|
# 131| getElement: [HashSplatExpr] ** ...
|
|
# 131| getAnOperand/getOperand/getReceiver: [MethodCall] call to baz
|
|
# 131| getReceiver: [SelfVariableAccess] self
|
|
# 134| getStmt: [ParenthesizedExpr] ( ... )
|
|
# 134| getStmt: [RangeLiteral] _ .. _
|
|
# 134| getBegin: [IntegerLiteral] 1
|
|
# 134| getEnd: [IntegerLiteral] 10
|
|
# 135| getStmt: [ParenthesizedExpr] ( ... )
|
|
# 135| getStmt: [RangeLiteral] _ ... _
|
|
# 135| getBegin: [IntegerLiteral] 1
|
|
# 135| getEnd: [IntegerLiteral] 10
|
|
# 136| getStmt: [ParenthesizedExpr] ( ... )
|
|
# 136| getStmt: [RangeLiteral] _ .. _
|
|
# 136| getBegin: [IntegerLiteral] 1
|
|
# 136| getEnd: [IntegerLiteral] 0
|
|
# 137| getStmt: [ParenthesizedExpr] ( ... )
|
|
# 137| getStmt: [RangeLiteral] _ .. _
|
|
# 137| getBegin: [MethodCall] call to start
|
|
# 137| getReceiver: [SelfVariableAccess] self
|
|
# 137| getEnd: [AddExpr] ... + ...
|
|
# 137| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 2
|
|
# 137| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 3
|
|
# 138| getStmt: [ParenthesizedExpr] ( ... )
|
|
# 138| getStmt: [RangeLiteral] _ .. _
|
|
# 138| getBegin: [IntegerLiteral] 1
|
|
# 139| getStmt: [ParenthesizedExpr] ( ... )
|
|
# 139| getStmt: [RangeLiteral] _ .. _
|
|
# 139| getEnd: [IntegerLiteral] 1
|
|
# 140| getStmt: [ParenthesizedExpr] ( ... )
|
|
# 140| getStmt: [RangeLiteral] _ .. _
|
|
# 140| getBegin: [IntegerLiteral] 0
|
|
# 140| getEnd: [UnaryMinusExpr] - ...
|
|
# 140| getAnOperand/getOperand/getReceiver: [IntegerLiteral] 1
|
|
# 143| getStmt: [SubshellLiteral] `ls -l`
|
|
# 143| getComponent: [StringTextComponent] ls -l
|
|
# 144| getStmt: [SubshellLiteral] `ls -l`
|
|
# 144| getComponent: [StringTextComponent] ls -l
|
|
# 145| getStmt: [SubshellLiteral] `du -d #{...} #{...} #{...}`
|
|
# 145| getComponent: [StringTextComponent] du -d
|
|
# 145| getComponent: [StringInterpolationComponent] #{...}
|
|
# 145| getStmt: [AddExpr] ... + ...
|
|
# 145| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 1
|
|
# 145| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 145| getComponent: [StringTextComponent]
|
|
# 145| getComponent: [StringInterpolationComponent] #{...}
|
|
# 145| getStmt: [LocalVariableAccess] bar
|
|
# 145| getComponent: [StringTextComponent]
|
|
# 145| getComponent: [StringInterpolationComponent] #{...}
|
|
# 145| getStmt: [ConstantReadAccess] BAR
|
|
# 146| getStmt: [SubshellLiteral] `du -d #{...}`
|
|
# 146| getComponent: [StringTextComponent] du -d
|
|
# 146| getComponent: [StringInterpolationComponent] #{...}
|
|
# 146| getStmt: [SubExpr] ... - ...
|
|
# 146| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 5
|
|
# 146| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 4
|
|
# 149| getStmt: [RegExpLiteral] //
|
|
# 150| getStmt: [RegExpLiteral] /foo/
|
|
# 150| getParsed: [RegExpConstant, RegExpNormalChar] foo
|
|
# 150| getComponent: [RegExpTextComponent] foo
|
|
# 151| getStmt: [RegExpLiteral] /foo/
|
|
# 151| getParsed: [RegExpConstant, RegExpNormalChar] foo
|
|
# 151| getComponent: [RegExpTextComponent] foo
|
|
# 152| getStmt: [RegExpLiteral] /foo+\sbar\S/
|
|
# 152| getParsed: [RegExpSequence] foo+\sbar\S
|
|
# 152| 0: [RegExpConstant, RegExpNormalChar] fo
|
|
# 152| 1: [RegExpPlus] o+
|
|
# 152| 0: [RegExpConstant, RegExpNormalChar] o
|
|
# 152| 2: [RegExpCharacterClassEscape] \s
|
|
# 152| 3: [RegExpConstant, RegExpNormalChar] bar
|
|
# 152| 4: [RegExpCharacterClassEscape] \S
|
|
# 152| getComponent: [RegExpTextComponent] foo+
|
|
# 152| getComponent: [RegExpEscapeSequenceComponent] \s
|
|
# 152| getComponent: [RegExpTextComponent] bar
|
|
# 152| getComponent: [RegExpEscapeSequenceComponent] \S
|
|
# 153| getStmt: [RegExpLiteral] /foo#{...}bar#{...}#{...}/
|
|
# 153| getParsed: [RegExpConstant, RegExpNormalChar] foo2barbarbar
|
|
# 153| getComponent: [RegExpTextComponent] foo
|
|
# 153| getComponent: [RegExpInterpolationComponent] #{...}
|
|
# 153| getStmt: [AddExpr] ... + ...
|
|
# 153| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 1
|
|
# 153| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 153| getComponent: [RegExpTextComponent] bar
|
|
# 153| getComponent: [RegExpInterpolationComponent] #{...}
|
|
# 153| getStmt: [LocalVariableAccess] bar
|
|
# 153| getComponent: [RegExpInterpolationComponent] #{...}
|
|
# 153| getStmt: [ConstantReadAccess] BAR
|
|
# 154| getStmt: [RegExpLiteral] /foo/
|
|
# 154| getComponent: [RegExpTextComponent] foo
|
|
# 155| getStmt: [RegExpLiteral] //
|
|
# 156| getStmt: [RegExpLiteral] /foo/
|
|
# 156| getParsed: [RegExpConstant, RegExpNormalChar] foo
|
|
# 156| getComponent: [RegExpTextComponent] foo
|
|
# 157| getStmt: [RegExpLiteral] /foo/
|
|
# 157| getParsed: [RegExpConstant, RegExpNormalChar] foo
|
|
# 157| getComponent: [RegExpTextComponent] foo
|
|
# 158| getStmt: [RegExpLiteral] /foo+\sbar\S/
|
|
# 158| getParsed: [RegExpSequence] foo+\sbar\S
|
|
# 158| 0: [RegExpConstant, RegExpNormalChar] fo
|
|
# 158| 1: [RegExpPlus] o+
|
|
# 158| 0: [RegExpConstant, RegExpNormalChar] o
|
|
# 158| 2: [RegExpCharacterClassEscape] \s
|
|
# 158| 3: [RegExpConstant, RegExpNormalChar] bar
|
|
# 158| 4: [RegExpCharacterClassEscape] \S
|
|
# 158| getComponent: [RegExpTextComponent] foo+
|
|
# 158| getComponent: [RegExpEscapeSequenceComponent] \s
|
|
# 158| getComponent: [RegExpTextComponent] bar
|
|
# 158| getComponent: [RegExpEscapeSequenceComponent] \S
|
|
# 159| getStmt: [RegExpLiteral] /foo#{...}bar#{...}#{...}/
|
|
# 159| getParsed: [RegExpConstant, RegExpNormalChar] foo2barbarbar
|
|
# 159| getComponent: [RegExpTextComponent] foo
|
|
# 159| getComponent: [RegExpInterpolationComponent] #{...}
|
|
# 159| getStmt: [AddExpr] ... + ...
|
|
# 159| getAnOperand/getLeftOperand/getReceiver: [IntegerLiteral] 1
|
|
# 159| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 159| getComponent: [RegExpTextComponent] bar
|
|
# 159| getComponent: [RegExpInterpolationComponent] #{...}
|
|
# 159| getStmt: [LocalVariableAccess] bar
|
|
# 159| getComponent: [RegExpInterpolationComponent] #{...}
|
|
# 159| getStmt: [ConstantReadAccess] BAR
|
|
# 160| getStmt: [RegExpLiteral] /foo/
|
|
# 160| getComponent: [RegExpTextComponent] foo
|
|
# 163| getStmt: [StringLiteral] "abcdefghijklmnopqrstuvwxyzabcdef"
|
|
# 163| getComponent: [StringTextComponent] abcdefghijklmnopqrstuvwxyzabcdef
|
|
# 164| getStmt: [StringLiteral] "foobarfoobarfoobarfoobarfooba..."
|
|
# 164| getComponent: [StringTextComponent] foobarfoobarfoobarfoobarfoobarfoo
|
|
# 165| getStmt: [StringLiteral] "foobar\\foobar\\foobar\\fooba..."
|
|
# 165| getComponent: [StringTextComponent] foobar
|
|
# 165| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 165| getComponent: [StringTextComponent] foobar
|
|
# 165| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 165| getComponent: [StringTextComponent] foobar
|
|
# 165| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 165| getComponent: [StringTextComponent] foobar
|
|
# 165| getComponent: [StringEscapeSequenceComponent] \\
|
|
# 165| getComponent: [StringTextComponent] foobar
|
|
# 168| getStmt: [MethodCall] call to run_sql
|
|
# 168| getReceiver: [SelfVariableAccess] self
|
|
# 168| getArgument: [HereDoc] <<SQL
|
|
# 168| getComponent: [StringTextComponent]
|
|
# 168| select * from table
|
|
# 168|
|
|
# 168| getArgument: [HereDoc] <<SQL
|
|
# 170| getComponent: [StringTextComponent]
|
|
# 170| where name =
|
|
# 171| getComponent: [StringInterpolationComponent] #{...}
|
|
# 171| getStmt: [MethodCall] call to name
|
|
# 171| getReceiver: [SelfVariableAccess] self
|
|
# 171| getComponent: [StringTextComponent]
|
|
# 171|
|
|
# 174| getStmt: [Method] m
|
|
# 175| getStmt: [AssignExpr] ... = ...
|
|
# 175| getAnOperand/getLeftOperand: [LocalVariableAccess] query
|
|
# 175| getAnOperand/getRightOperand: [HereDoc] <<-BLA
|
|
# 175| getComponent: [StringTextComponent]
|
|
# 175| some text
|
|
# 176| getComponent: [StringEscapeSequenceComponent] \n
|
|
# 176| getComponent: [StringTextComponent] and some more
|
|
# 176|
|
|
# 180| getStmt: [AssignExpr] ... = ...
|
|
# 180| getAnOperand/getLeftOperand: [LocalVariableAccess] query
|
|
# 180| getAnOperand/getRightOperand: [HereDoc] <<~SQUIGGLY
|
|
# 180| getComponent: [StringTextComponent]
|
|
# 180| indented stuff
|
|
# 180|
|
|
# 184| getStmt: [AssignExpr] ... = ...
|
|
# 184| getAnOperand/getLeftOperand: [LocalVariableAccess] query
|
|
# 184| getAnOperand/getRightOperand: [HereDoc] <<"DOC"
|
|
# 184| getComponent: [StringTextComponent]
|
|
# 184| text with
|
|
# 185| getComponent: [StringInterpolationComponent] #{...}
|
|
# 185| getStmt: [MethodCall] call to interpolation
|
|
# 185| getReceiver: [SelfVariableAccess] self
|
|
# 185| getComponent: [StringTextComponent] !
|
|
# 185|
|
|
# 189| getStmt: [AssignExpr] ... = ...
|
|
# 189| getAnOperand/getLeftOperand: [LocalVariableAccess] query
|
|
# 189| getAnOperand/getRightOperand: [HereDoc] <<'DOC'
|
|
# 189| getComponent: [StringTextComponent]
|
|
# 189| text without #{ interpolation } !
|
|
# 189|
|
|
# 193| getStmt: [AssignExpr] ... = ...
|
|
# 193| getAnOperand/getLeftOperand: [LocalVariableAccess] output
|
|
# 193| getAnOperand/getRightOperand: [HereDoc] <<`SCRIPT`
|
|
# 193| getComponent: [StringTextComponent]
|
|
# 193| cat file.txt
|
|
# 193|
|
|
# 197| getStmt: [AssignExpr] ... = ...
|
|
# 197| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 197| getAnOperand/getRightOperand: [IntegerLiteral] 42
|
|
# 198| getStmt: [HashLiteral] {...}
|
|
# 198| getElement: [Pair] Pair
|
|
# 198| getKey: [SymbolLiteral] :x
|
|
# 198| getComponent: [StringTextComponent] x
|
|
# 198| getValue: [LocalVariableAccess] x
|
|
# 198| getElement: [Pair] Pair
|
|
# 198| getKey: [SymbolLiteral] :y
|
|
# 198| getComponent: [StringTextComponent] y
|
|
# 198| getValue: [IntegerLiteral] 5
|
|
# 199| getStmt: [HashLiteral] {...}
|
|
# 199| getElement: [Pair] Pair
|
|
# 199| getKey: [SymbolLiteral] :y
|
|
# 199| getComponent: [StringTextComponent] y
|
|
# 199| getValue: [MethodCall] call to y
|
|
# 199| getElement: [Pair] Pair
|
|
# 199| getKey: [SymbolLiteral] :Z
|
|
# 199| getComponent: [StringTextComponent] Z
|
|
# 199| getValue: [ConstantReadAccess] Z
|
|
# 201| getStmt: [StringLiteral] "@foo: #{...} @@bar: #{...} $_..."
|
|
# 201| getComponent: [StringTextComponent] @foo:
|
|
# 201| getComponent: [StringInterpolationComponent] #{...}
|
|
# 201| getStmt: [InstanceVariableAccess] @foo
|
|
# 201| getReceiver: [SelfVariableAccess] self
|
|
# 201| getComponent: [StringTextComponent] @@bar:
|
|
# 201| getComponent: [StringInterpolationComponent] #{...}
|
|
# 201| getStmt: [ClassVariableAccess] @@bar
|
|
# 201| getComponent: [StringTextComponent] $_:
|
|
# 201| getComponent: [StringInterpolationComponent] #{...}
|
|
# 201| getStmt: [GlobalVariableAccess] $_
|
|
control/loops.rb:
|
|
# 1| [Toplevel] loops.rb
|
|
# 2| getStmt: [AssignExpr] ... = ...
|
|
# 2| getAnOperand/getLeftOperand: [LocalVariableAccess] foo
|
|
# 2| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 3| getStmt: [AssignExpr] ... = ...
|
|
# 3| getAnOperand/getLeftOperand: [LocalVariableAccess] sum
|
|
# 3| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 4| getStmt: [AssignExpr] ... = ...
|
|
# 4| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 4| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 5| getStmt: [AssignExpr] ... = ...
|
|
# 5| getAnOperand/getLeftOperand: [LocalVariableAccess] y
|
|
# 5| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 6| getStmt: [AssignExpr] ... = ...
|
|
# 6| getAnOperand/getLeftOperand: [LocalVariableAccess] z
|
|
# 6| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 9| getStmt: [ForExpr] for ... in ...
|
|
# 9| getPattern: [LocalVariableAccess] n
|
|
# 9| getValue: [RangeLiteral] _ .. _
|
|
# 9| getBegin: [IntegerLiteral] 1
|
|
# 9| getEnd: [IntegerLiteral] 10
|
|
# 9| getBody: [StmtSequence] do ...
|
|
# 10| getStmt: [AssignAddExpr] ... += ...
|
|
# 10| getAnOperand/getLeftOperand: [LocalVariableAccess] sum
|
|
# 10| getAnOperand/getRightOperand: [LocalVariableAccess] n
|
|
# 11| getStmt: [AssignExpr] ... = ...
|
|
# 11| getAnOperand/getLeftOperand: [LocalVariableAccess] foo
|
|
# 11| getAnOperand/getRightOperand: [LocalVariableAccess] n
|
|
# 16| getStmt: [ForExpr] for ... in ...
|
|
# 16| getPattern: [LocalVariableAccess] n
|
|
# 16| getValue: [RangeLiteral] _ .. _
|
|
# 16| getBegin: [IntegerLiteral] 1
|
|
# 16| getEnd: [IntegerLiteral] 10
|
|
# 16| getBody: [StmtSequence] do ...
|
|
# 17| getStmt: [AssignAddExpr] ... += ...
|
|
# 17| getAnOperand/getLeftOperand: [LocalVariableAccess] sum
|
|
# 17| getAnOperand/getRightOperand: [LocalVariableAccess] n
|
|
# 18| getStmt: [AssignSubExpr] ... -= ...
|
|
# 18| getAnOperand/getLeftOperand: [LocalVariableAccess] foo
|
|
# 18| getAnOperand/getRightOperand: [LocalVariableAccess] n
|
|
# 22| getStmt: [ForExpr] for ... in ...
|
|
# 22| getPattern: [DestructuredLhsExpr] (..., ...)
|
|
# 22| getElement: [LocalVariableAccess] key
|
|
# 22| getElement: [LocalVariableAccess] value
|
|
# 22| getValue: [HashLiteral] {...}
|
|
# 22| getElement: [Pair] Pair
|
|
# 22| getKey: [SymbolLiteral] :foo
|
|
# 22| getComponent: [StringTextComponent] foo
|
|
# 22| getValue: [IntegerLiteral] 0
|
|
# 22| getElement: [Pair] Pair
|
|
# 22| getKey: [SymbolLiteral] :bar
|
|
# 22| getComponent: [StringTextComponent] bar
|
|
# 22| getValue: [IntegerLiteral] 1
|
|
# 22| getBody: [StmtSequence] do ...
|
|
# 23| getStmt: [AssignAddExpr] ... += ...
|
|
# 23| getAnOperand/getLeftOperand: [LocalVariableAccess] sum
|
|
# 23| getAnOperand/getRightOperand: [LocalVariableAccess] value
|
|
# 24| getStmt: [AssignMulExpr] ... *= ...
|
|
# 24| getAnOperand/getLeftOperand: [LocalVariableAccess] foo
|
|
# 24| getAnOperand/getRightOperand: [LocalVariableAccess] value
|
|
# 28| getStmt: [ForExpr] for ... in ...
|
|
# 28| getPattern: [DestructuredLhsExpr] (..., ...)
|
|
# 28| getElement: [LocalVariableAccess] key
|
|
# 28| getElement: [LocalVariableAccess] value
|
|
# 28| getValue: [HashLiteral] {...}
|
|
# 28| getElement: [Pair] Pair
|
|
# 28| getKey: [SymbolLiteral] :foo
|
|
# 28| getComponent: [StringTextComponent] foo
|
|
# 28| getValue: [IntegerLiteral] 0
|
|
# 28| getElement: [Pair] Pair
|
|
# 28| getKey: [SymbolLiteral] :bar
|
|
# 28| getComponent: [StringTextComponent] bar
|
|
# 28| getValue: [IntegerLiteral] 1
|
|
# 28| getBody: [StmtSequence] do ...
|
|
# 29| getStmt: [AssignAddExpr] ... += ...
|
|
# 29| getAnOperand/getLeftOperand: [LocalVariableAccess] sum
|
|
# 29| getAnOperand/getRightOperand: [LocalVariableAccess] value
|
|
# 30| getStmt: [AssignDivExpr] ... /= ...
|
|
# 30| getAnOperand/getLeftOperand: [LocalVariableAccess] foo
|
|
# 30| getAnOperand/getRightOperand: [LocalVariableAccess] value
|
|
# 31| getStmt: [BreakStmt] break
|
|
# 35| getStmt: [WhileExpr] while ...
|
|
# 35| getCondition: [LTExpr] ... < ...
|
|
# 35| getAnOperand/getLeftOperand/getLesserOperand/getReceiver: [LocalVariableAccess] x
|
|
# 35| getAnOperand/getArgument/getGreaterOperand/getRightOperand: [LocalVariableAccess] y
|
|
# 35| getBody: [StmtSequence] do ...
|
|
# 36| getStmt: [AssignAddExpr] ... += ...
|
|
# 36| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 36| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 37| getStmt: [AssignAddExpr] ... += ...
|
|
# 37| getAnOperand/getLeftOperand: [LocalVariableAccess] z
|
|
# 37| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 38| getStmt: [NextStmt] next
|
|
# 42| getStmt: [WhileExpr] while ...
|
|
# 42| getCondition: [LTExpr] ... < ...
|
|
# 42| getAnOperand/getLeftOperand/getLesserOperand/getReceiver: [LocalVariableAccess] x
|
|
# 42| getAnOperand/getArgument/getGreaterOperand/getRightOperand: [LocalVariableAccess] y
|
|
# 42| getBody: [StmtSequence] do ...
|
|
# 43| getStmt: [AssignAddExpr] ... += ...
|
|
# 43| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 43| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 44| getStmt: [AssignAddExpr] ... += ...
|
|
# 44| getAnOperand/getLeftOperand: [LocalVariableAccess] z
|
|
# 44| getAnOperand/getRightOperand: [IntegerLiteral] 2
|
|
# 48| getStmt: [WhileModifierExpr] ... while ...
|
|
# 48| getBody: [AssignAddExpr] ... += ...
|
|
# 48| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 48| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 48| getCondition: [GEExpr] ... >= ...
|
|
# 48| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] y
|
|
# 48| getAnOperand/getArgument/getLesserOperand/getRightOperand: [LocalVariableAccess] x
|
|
# 51| getStmt: [UntilExpr] until ...
|
|
# 51| getCondition: [EqExpr] ... == ...
|
|
# 51| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 51| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] y
|
|
# 51| getBody: [StmtSequence] do ...
|
|
# 52| getStmt: [AssignAddExpr] ... += ...
|
|
# 52| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 52| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 53| getStmt: [AssignSubExpr] ... -= ...
|
|
# 53| getAnOperand/getLeftOperand: [LocalVariableAccess] z
|
|
# 53| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 57| getStmt: [UntilExpr] until ...
|
|
# 57| getCondition: [GTExpr] ... > ...
|
|
# 57| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 57| getAnOperand/getArgument/getLesserOperand/getRightOperand: [LocalVariableAccess] y
|
|
# 57| getBody: [StmtSequence] do ...
|
|
# 58| getStmt: [AssignAddExpr] ... += ...
|
|
# 58| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 58| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 59| getStmt: [AssignSubExpr] ... -= ...
|
|
# 59| getAnOperand/getLeftOperand: [LocalVariableAccess] z
|
|
# 59| getAnOperand/getRightOperand: [IntegerLiteral] 4
|
|
# 63| getStmt: [UntilModifierExpr] ... until ...
|
|
# 63| getBody: [AssignSubExpr] ... -= ...
|
|
# 63| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 63| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 63| getCondition: [EqExpr] ... == ...
|
|
# 63| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 63| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 0
|
|
# 66| getStmt: [WhileExpr] while ...
|
|
# 66| getCondition: [LTExpr] ... < ...
|
|
# 66| getAnOperand/getLeftOperand/getLesserOperand/getReceiver: [LocalVariableAccess] x
|
|
# 66| getAnOperand/getArgument/getGreaterOperand/getRightOperand: [LocalVariableAccess] y
|
|
# 66| getBody: [StmtSequence] do ...
|
|
misc/misc.erb:
|
|
# 2| [Toplevel] misc.erb
|
|
# 2| getStmt: [MethodCall] call to require_asset
|
|
# 2| getReceiver: [SelfVariableAccess] self
|
|
# 2| getArgument: [StringLiteral] "main_include_admin.js"
|
|
# 2| getComponent: [StringTextComponent] main_include_admin.js
|
|
misc/misc.rb:
|
|
# 1| [Toplevel] misc.rb
|
|
# 1| getStmt: [AssignExpr] ... = ...
|
|
# 1| getAnOperand/getLeftOperand: [LocalVariableAccess] bar
|
|
# 1| getAnOperand/getRightOperand: [StringLiteral] "bar"
|
|
# 1| getComponent: [StringTextComponent] bar
|
|
# 3| getStmt: [UndefStmt] undef ...
|
|
# 3| getMethodName: [MethodName] foo
|
|
# 3| getMethodName: [MethodName] :foo
|
|
# 3| getComponent: [StringTextComponent] foo
|
|
# 3| getMethodName: [MethodName] foo=
|
|
# 3| getMethodName: [MethodName] []
|
|
# 3| getMethodName: [MethodName] []=
|
|
# 4| getStmt: [UndefStmt] undef ...
|
|
# 4| getMethodName: [MethodName] :"foo_#{...}"
|
|
# 4| getComponent: [StringTextComponent] foo_
|
|
# 4| getComponent: [StringInterpolationComponent] #{...}
|
|
# 4| getStmt: [LocalVariableAccess] bar
|
|
# 5| getStmt: [UndefStmt] undef ...
|
|
# 5| getMethodName: [MethodName] nil
|
|
# 5| getMethodName: [MethodName] true
|
|
# 5| getMethodName: [MethodName] false
|
|
# 5| getMethodName: [MethodName] super
|
|
# 5| getMethodName: [MethodName] self
|
|
# 7| getStmt: [AliasStmt] alias ...
|
|
# 7| getNewName: [MethodName] new
|
|
# 7| getOldName: [MethodName] :old
|
|
# 7| getComponent: [StringTextComponent] old
|
|
# 8| getStmt: [AliasStmt] alias ...
|
|
# 8| getNewName: [MethodName] foo=
|
|
# 8| getOldName: [MethodName] []=
|
|
# 9| getStmt: [AliasStmt] alias ...
|
|
# 9| getNewName: [MethodName] super
|
|
# 9| getOldName: [MethodName] self
|
|
# 10| getStmt: [AliasStmt] alias ...
|
|
# 10| getNewName: [MethodName] :"\n#{...}"
|
|
# 10| getComponent: [StringEscapeSequenceComponent] \n
|
|
# 10| getComponent: [StringInterpolationComponent] #{...}
|
|
# 10| getStmt: [LocalVariableAccess] bar
|
|
# 10| getOldName: [MethodName] :"foo"
|
|
# 10| getComponent: [StringTextComponent] foo
|
|
modules/modules.rb:
|
|
# 1| [Toplevel] modules.rb
|
|
# 1| getStmt: [ModuleDeclaration] Empty
|
|
# 4| getStmt: [ModuleDeclaration] Foo
|
|
# 5| getStmt: [ModuleDeclaration] Bar
|
|
# 6| getStmt: [ClassDeclaration] ClassInFooBar
|
|
# 9| getStmt: [Method] method_in_foo_bar
|
|
# 12| getStmt: [MethodCall] call to puts
|
|
# 12| getReceiver: [SelfVariableAccess] self
|
|
# 12| getArgument: [StringLiteral] "module Foo::Bar"
|
|
# 12| getComponent: [StringTextComponent] module Foo::Bar
|
|
# 13| getStmt: [AssignExpr] ... = ...
|
|
# 13| getAnOperand/getLeftOperand: [GlobalVariableAccess] $global_var
|
|
# 13| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 16| getStmt: [Method] method_in_foo
|
|
# 19| getStmt: [ClassDeclaration] ClassInFoo
|
|
# 22| getStmt: [MethodCall] call to puts
|
|
# 22| getReceiver: [SelfVariableAccess] self
|
|
# 22| getArgument: [StringLiteral] "module Foo"
|
|
# 22| getComponent: [StringTextComponent] module Foo
|
|
# 23| getStmt: [AssignExpr] ... = ...
|
|
# 23| getAnOperand/getLeftOperand: [GlobalVariableAccess] $global_var
|
|
# 23| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 26| getStmt: [ModuleDeclaration] Foo
|
|
# 27| getStmt: [Method] method_in_another_definition_of_foo
|
|
# 30| getStmt: [ClassDeclaration] ClassInAnotherDefinitionOfFoo
|
|
# 33| getStmt: [MethodCall] call to puts
|
|
# 33| getReceiver: [SelfVariableAccess] self
|
|
# 33| getArgument: [StringLiteral] "module Foo again"
|
|
# 33| getComponent: [StringTextComponent] module Foo again
|
|
# 34| getStmt: [AssignExpr] ... = ...
|
|
# 34| getAnOperand/getLeftOperand: [GlobalVariableAccess] $global_var
|
|
# 34| getAnOperand/getRightOperand: [IntegerLiteral] 2
|
|
# 37| getStmt: [ModuleDeclaration] Bar
|
|
# 38| getStmt: [Method] method_a
|
|
# 41| getStmt: [Method] method_b
|
|
# 44| getStmt: [MethodCall] call to puts
|
|
# 44| getReceiver: [SelfVariableAccess] self
|
|
# 44| getArgument: [StringLiteral] "module Bar"
|
|
# 44| getComponent: [StringTextComponent] module Bar
|
|
# 45| getStmt: [AssignExpr] ... = ...
|
|
# 45| getAnOperand/getLeftOperand: [GlobalVariableAccess] $global_var
|
|
# 45| getAnOperand/getRightOperand: [IntegerLiteral] 3
|
|
# 48| getStmt: [ModuleDeclaration] Bar
|
|
# 48| getScopeExpr: [ConstantReadAccess] Foo
|
|
# 49| getStmt: [ClassDeclaration] ClassInAnotherDefinitionOfFooBar
|
|
# 52| getStmt: [Method] method_in_another_definition_of_foo_bar
|
|
# 55| getStmt: [MethodCall] call to puts
|
|
# 55| getReceiver: [SelfVariableAccess] self
|
|
# 55| getArgument: [StringLiteral] "module Foo::Bar again"
|
|
# 55| getComponent: [StringTextComponent] module Foo::Bar again
|
|
# 56| getStmt: [AssignExpr] ... = ...
|
|
# 56| getAnOperand/getLeftOperand: [GlobalVariableAccess] $global_var
|
|
# 56| getAnOperand/getRightOperand: [IntegerLiteral] 4
|
|
# 60| getStmt: [ModuleDeclaration] MyModuleInGlobalScope
|
|
# 63| getStmt: [ModuleDeclaration] Test
|
|
# 65| getStmt: [ModuleDeclaration] Foo1
|
|
# 66| getStmt: [ClassDeclaration] Bar
|
|
# 66| getScopeExpr: [ConstantReadAccess] Foo1
|
|
# 70| getStmt: [ModuleDeclaration] Foo2
|
|
# 71| getStmt: [ModuleDeclaration] Foo2
|
|
# 72| getStmt: [ClassDeclaration] Bar
|
|
# 72| getScopeExpr: [ConstantReadAccess] Foo2
|
|
# 76| getStmt: [ModuleDeclaration] Foo3
|
|
# 77| getStmt: [AssignExpr] ... = ...
|
|
# 77| getAnOperand/getLeftOperand: [ConstantAssignment] Foo3
|
|
# 77| getAnOperand/getRightOperand: [ConstantReadAccess] Object
|
|
# 78| getStmt: [ClassDeclaration] Bar
|
|
# 78| getScopeExpr: [ConstantReadAccess] Foo3
|
|
# 83| getStmt: [ModuleDeclaration] Other
|
|
# 84| getStmt: [ModuleDeclaration] Foo1
|
|
# 88| getStmt: [ModuleDeclaration] IncludeTest
|
|
# 89| getStmt: [MethodCall] call to include
|
|
# 89| getReceiver: [SelfVariableAccess] self
|
|
# 89| getArgument: [ConstantReadAccess] Test
|
|
# 90| getStmt: [MethodCall] call to module_eval
|
|
# 90| getReceiver: [ConstantReadAccess] Object
|
|
# 90| getBlock: [BraceBlock] { ... }
|
|
# 90| getStmt: [MethodCall] call to prepend
|
|
# 90| getReceiver: [SelfVariableAccess] self
|
|
# 90| getArgument: [ConstantReadAccess] Other
|
|
# 91| getStmt: [ModuleDeclaration] Y
|
|
# 91| getScopeExpr: [ConstantReadAccess] Foo1
|
|
# 95| getStmt: [ModuleDeclaration] IncludeTest2
|
|
# 96| getStmt: [MethodCall] call to include
|
|
# 96| getReceiver: [SelfVariableAccess] self
|
|
# 96| getArgument: [ConstantReadAccess] Test
|
|
# 97| getStmt: [ModuleDeclaration] Z
|
|
# 97| getScopeExpr: [ConstantReadAccess] Foo1
|
|
# 101| getStmt: [ModuleDeclaration] PrependTest
|
|
# 102| getStmt: [MethodCall] call to prepend
|
|
# 102| getReceiver: [SelfVariableAccess] self
|
|
# 102| getArgument: [ConstantReadAccess] Test
|
|
# 103| getStmt: [ModuleDeclaration] Y
|
|
# 103| getScopeExpr: [ConstantReadAccess] Foo2
|
|
# 107| getStmt: [ModuleDeclaration] MM
|
|
# 108| getStmt: [ModuleDeclaration] MM
|
|
# 108| getScopeExpr: [ConstantReadAccess] MM
|
|
# 112| getStmt: [ClassDeclaration] YY
|
|
# 115| getStmt: [ModuleDeclaration] XX
|
|
# 116| getStmt: [ClassDeclaration] YY
|
|
# 116| getSuperclassExpr: [ConstantReadAccess] YY
|
|
# 120| getStmt: [ModuleDeclaration] Baz
|
|
# 120| getScopeExpr: [ConstantReadAccess] Bar
|
|
# 120| getScopeExpr: [ConstantReadAccess] Foo1
|
|
# 120| getScopeExpr: [ConstantReadAccess] Test
|
|
operations/operations.rb:
|
|
# 1| [Toplevel] operations.rb
|
|
# 3| getStmt: [AssignExpr] ... = ...
|
|
# 3| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 3| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 4| getStmt: [AssignExpr] ... = ...
|
|
# 4| getAnOperand/getLeftOperand: [LocalVariableAccess] b
|
|
# 4| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 5| getStmt: [AssignExpr] ... = ...
|
|
# 5| getAnOperand/getLeftOperand: [LocalVariableAccess] bar
|
|
# 5| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 6| getStmt: [AssignExpr] ... = ...
|
|
# 6| getAnOperand/getLeftOperand: [LocalVariableAccess] base
|
|
# 6| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 7| getStmt: [AssignExpr] ... = ...
|
|
# 7| getAnOperand/getLeftOperand: [LocalVariableAccess] baz
|
|
# 7| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 8| getStmt: [AssignExpr] ... = ...
|
|
# 8| getAnOperand/getLeftOperand: [LocalVariableAccess] foo
|
|
# 8| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 9| getStmt: [AssignExpr] ... = ...
|
|
# 9| getAnOperand/getLeftOperand: [LocalVariableAccess] handle
|
|
# 9| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 10| getStmt: [AssignExpr] ... = ...
|
|
# 10| getAnOperand/getLeftOperand: [LocalVariableAccess] m
|
|
# 10| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 11| getStmt: [AssignExpr] ... = ...
|
|
# 11| getAnOperand/getLeftOperand: [LocalVariableAccess] mask
|
|
# 11| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 12| getStmt: [AssignExpr] ... = ...
|
|
# 12| getAnOperand/getLeftOperand: [LocalVariableAccess] n
|
|
# 12| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 13| getStmt: [AssignExpr] ... = ...
|
|
# 13| getAnOperand/getLeftOperand: [LocalVariableAccess] name
|
|
# 13| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 14| getStmt: [AssignExpr] ... = ...
|
|
# 14| getAnOperand/getLeftOperand: [LocalVariableAccess] num
|
|
# 14| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 15| getStmt: [AssignExpr] ... = ...
|
|
# 15| getAnOperand/getLeftOperand: [LocalVariableAccess] power
|
|
# 15| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 16| getStmt: [AssignExpr] ... = ...
|
|
# 16| getAnOperand/getLeftOperand: [LocalVariableAccess] qux
|
|
# 16| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 17| getStmt: [AssignExpr] ... = ...
|
|
# 17| getAnOperand/getLeftOperand: [LocalVariableAccess] w
|
|
# 17| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 18| getStmt: [AssignExpr] ... = ...
|
|
# 18| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 18| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 19| getStmt: [AssignExpr] ... = ...
|
|
# 19| getAnOperand/getLeftOperand: [LocalVariableAccess] y
|
|
# 19| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 20| getStmt: [AssignExpr] ... = ...
|
|
# 20| getAnOperand/getLeftOperand: [LocalVariableAccess] z
|
|
# 20| getAnOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 23| getStmt: [NotExpr] ! ...
|
|
# 23| getAnOperand/getOperand/getReceiver: [LocalVariableAccess] a
|
|
# 24| getStmt: [NotExpr] not ...
|
|
# 24| getAnOperand/getOperand/getReceiver: [LocalVariableAccess] b
|
|
# 25| getStmt: [UnaryPlusExpr] + ...
|
|
# 25| getAnOperand/getOperand/getReceiver: [IntegerLiteral] 14
|
|
# 26| getStmt: [UnaryMinusExpr] - ...
|
|
# 26| getAnOperand/getOperand/getReceiver: [IntegerLiteral] 7
|
|
# 27| getStmt: [ComplementExpr] ~ ...
|
|
# 27| getAnOperand/getOperand/getReceiver: [LocalVariableAccess] x
|
|
# 28| getStmt: [DefinedExpr] defined? ...
|
|
# 28| getAnOperand/getOperand/getReceiver: [LocalVariableAccess] foo
|
|
# 29| getStmt: [Method] foo
|
|
# 29| getStmt: [ReturnStmt] return
|
|
# 29| getValue: [ArgumentList] ..., ...
|
|
# 29| getElement: [IntegerLiteral] 1
|
|
# 29| getElement: [SplatExpr] * ...
|
|
# 29| getAnOperand/getOperand/getReceiver: [ArrayLiteral] [...]
|
|
# 29| getElement: [IntegerLiteral] 2
|
|
# 29| getElement: [Pair] Pair
|
|
# 29| getKey: [SymbolLiteral] :a
|
|
# 29| getComponent: [StringTextComponent] a
|
|
# 29| getValue: [IntegerLiteral] 3
|
|
# 29| getElement: [HashSplatExpr] ** ...
|
|
# 29| getAnOperand/getOperand/getReceiver: [HashLiteral] {...}
|
|
# 29| getElement: [Pair] Pair
|
|
# 29| getKey: [SymbolLiteral] :b
|
|
# 29| getComponent: [StringTextComponent] b
|
|
# 29| getValue: [IntegerLiteral] 4
|
|
# 29| getElement: [Pair] Pair
|
|
# 29| getKey: [SymbolLiteral] :c
|
|
# 29| getComponent: [StringTextComponent] c
|
|
# 29| getValue: [IntegerLiteral] 5
|
|
# 32| getStmt: [AddExpr] ... + ...
|
|
# 32| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] w
|
|
# 32| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 234
|
|
# 33| getStmt: [SubExpr] ... - ...
|
|
# 33| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 33| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 17
|
|
# 34| getStmt: [MulExpr] ... * ...
|
|
# 34| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] y
|
|
# 34| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 10
|
|
# 35| getStmt: [DivExpr] ... / ...
|
|
# 35| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] z
|
|
# 35| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 2
|
|
# 36| getStmt: [ModuloExpr] ... % ...
|
|
# 36| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] num
|
|
# 36| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 2
|
|
# 37| getStmt: [ExponentExpr] ... ** ...
|
|
# 37| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] base
|
|
# 37| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] power
|
|
# 40| getStmt: [LogicalAndExpr] ... && ...
|
|
# 40| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] foo
|
|
# 40| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] bar
|
|
# 41| getStmt: [LogicalAndExpr] ... and ...
|
|
# 41| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] baz
|
|
# 41| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] qux
|
|
# 42| getStmt: [LogicalOrExpr] ... or ...
|
|
# 42| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 42| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] b
|
|
# 43| getStmt: [LogicalOrExpr] ... || ...
|
|
# 43| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 43| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] y
|
|
# 46| getStmt: [LShiftExpr] ... << ...
|
|
# 46| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 46| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 3
|
|
# 47| getStmt: [RShiftExpr] ... >> ...
|
|
# 47| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] y
|
|
# 47| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 16
|
|
# 48| getStmt: [BitwiseAndExpr] ... & ...
|
|
# 48| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] foo
|
|
# 48| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 0xff
|
|
# 49| getStmt: [BitwiseOrExpr] ... | ...
|
|
# 49| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] bar
|
|
# 49| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 0x02
|
|
# 50| getStmt: [BitwiseXorExpr] ... ^ ...
|
|
# 50| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] baz
|
|
# 50| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] qux
|
|
# 53| getStmt: [EqExpr] ... == ...
|
|
# 53| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 53| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] y
|
|
# 54| getStmt: [NEExpr] ... != ...
|
|
# 54| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 54| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 123
|
|
# 55| getStmt: [CaseEqExpr] ... === ...
|
|
# 55| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] m
|
|
# 55| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] n
|
|
# 58| getStmt: [GTExpr] ... > ...
|
|
# 58| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 58| getAnOperand/getArgument/getLesserOperand/getRightOperand: [IntegerLiteral] 0
|
|
# 59| getStmt: [GEExpr] ... >= ...
|
|
# 59| getAnOperand/getGreaterOperand/getLeftOperand/getReceiver: [LocalVariableAccess] y
|
|
# 59| getAnOperand/getArgument/getLesserOperand/getRightOperand: [IntegerLiteral] 100
|
|
# 60| getStmt: [LTExpr] ... < ...
|
|
# 60| getAnOperand/getLeftOperand/getLesserOperand/getReceiver: [LocalVariableAccess] a
|
|
# 60| getAnOperand/getArgument/getGreaterOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 61| getStmt: [LEExpr] ... <= ...
|
|
# 61| getAnOperand/getLeftOperand/getLesserOperand/getReceiver: [IntegerLiteral] 7
|
|
# 61| getAnOperand/getArgument/getGreaterOperand/getRightOperand: [LocalVariableAccess] foo
|
|
# 64| getStmt: [SpaceshipExpr] ... <=> ...
|
|
# 64| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 64| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] b
|
|
# 65| getStmt: [RegExpMatchExpr] ... =~ ...
|
|
# 65| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] name
|
|
# 65| getAnOperand/getArgument/getRightOperand: [RegExpLiteral] /foo.*/
|
|
# 65| getParsed: [RegExpSequence] foo.*
|
|
# 65| 0: [RegExpConstant, RegExpNormalChar] foo
|
|
# 65| 1: [RegExpStar] .*
|
|
# 65| 0: [RegExpDot] .
|
|
# 65| getComponent: [RegExpTextComponent] foo.*
|
|
# 66| getStmt: [NoRegExpMatchExpr] ... !~ ...
|
|
# 66| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] handle
|
|
# 66| getAnOperand/getArgument/getRightOperand: [RegExpLiteral] /.*bar/
|
|
# 66| getParsed: [RegExpSequence] .*bar
|
|
# 66| 0: [RegExpStar] .*
|
|
# 66| 0: [RegExpDot] .
|
|
# 66| 1: [RegExpConstant, RegExpNormalChar] bar
|
|
# 66| getComponent: [RegExpTextComponent] .*bar
|
|
# 69| getStmt: [AssignAddExpr] ... += ...
|
|
# 69| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 69| getAnOperand/getRightOperand: [IntegerLiteral] 128
|
|
# 70| getStmt: [AssignSubExpr] ... -= ...
|
|
# 70| getAnOperand/getLeftOperand: [LocalVariableAccess] y
|
|
# 70| getAnOperand/getRightOperand: [IntegerLiteral] 32
|
|
# 71| getStmt: [AssignMulExpr] ... *= ...
|
|
# 71| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 71| getAnOperand/getRightOperand: [IntegerLiteral] 12
|
|
# 72| getStmt: [AssignDivExpr] ... /= ...
|
|
# 72| getAnOperand/getLeftOperand: [LocalVariableAccess] b
|
|
# 72| getAnOperand/getRightOperand: [IntegerLiteral] 4
|
|
# 73| getStmt: [AssignModuloExpr] ... %= ...
|
|
# 73| getAnOperand/getLeftOperand: [LocalVariableAccess] z
|
|
# 73| getAnOperand/getRightOperand: [IntegerLiteral] 2
|
|
# 74| getStmt: [AssignExponentExpr] ... **= ...
|
|
# 74| getAnOperand/getLeftOperand: [LocalVariableAccess] foo
|
|
# 74| getAnOperand/getRightOperand: [LocalVariableAccess] bar
|
|
# 77| getStmt: [AssignLogicalAndExpr] ... &&= ...
|
|
# 77| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 77| getAnOperand/getRightOperand: [LocalVariableAccess] y
|
|
# 78| getStmt: [AssignLogicalOrExpr] ... ||= ...
|
|
# 78| getAnOperand/getLeftOperand: [LocalVariableAccess] a
|
|
# 78| getAnOperand/getRightOperand: [LocalVariableAccess] b
|
|
# 81| getStmt: [AssignLShiftExpr] ... <<= ...
|
|
# 81| getAnOperand/getLeftOperand: [LocalVariableAccess] x
|
|
# 81| getAnOperand/getRightOperand: [IntegerLiteral] 2
|
|
# 82| getStmt: [AssignRShiftExpr] ... >>= ...
|
|
# 82| getAnOperand/getLeftOperand: [LocalVariableAccess] y
|
|
# 82| getAnOperand/getRightOperand: [IntegerLiteral] 3
|
|
# 83| getStmt: [AssignBitwiseAndExpr] ... &= ...
|
|
# 83| getAnOperand/getLeftOperand: [LocalVariableAccess] foo
|
|
# 83| getAnOperand/getRightOperand: [LocalVariableAccess] mask
|
|
# 84| getStmt: [AssignBitwiseOrExpr] ... |= ...
|
|
# 84| getAnOperand/getLeftOperand: [LocalVariableAccess] bar
|
|
# 84| getAnOperand/getRightOperand: [IntegerLiteral] 0x01
|
|
# 85| getStmt: [AssignBitwiseXorExpr] ... ^= ...
|
|
# 85| getAnOperand/getLeftOperand: [LocalVariableAccess] baz
|
|
# 85| getAnOperand/getRightOperand: [LocalVariableAccess] qux
|
|
# 87| getStmt: [ClassDeclaration] X
|
|
# 88| getStmt: [AssignExpr] ... = ...
|
|
# 88| getAnOperand/getLeftOperand: [InstanceVariableAccess] @x
|
|
# 88| getReceiver: [SelfVariableAccess] self
|
|
# 88| getAnOperand/getRightOperand: [IntegerLiteral] 1
|
|
# 89| getStmt: [AssignAddExpr] ... += ...
|
|
# 89| getAnOperand/getLeftOperand: [InstanceVariableAccess] @x
|
|
# 89| getReceiver: [SelfVariableAccess] self
|
|
# 89| getAnOperand/getRightOperand: [IntegerLiteral] 2
|
|
# 91| getStmt: [AssignExpr] ... = ...
|
|
# 91| getAnOperand/getLeftOperand: [ClassVariableAccess] @@y
|
|
# 91| getAnOperand/getRightOperand: [IntegerLiteral] 3
|
|
# 92| getStmt: [AssignDivExpr] ... /= ...
|
|
# 92| getAnOperand/getLeftOperand: [ClassVariableAccess] @@y
|
|
# 92| getAnOperand/getRightOperand: [IntegerLiteral] 4
|
|
# 95| getStmt: [AssignExpr] ... = ...
|
|
# 95| getAnOperand/getLeftOperand: [GlobalVariableAccess] $global_var
|
|
# 95| getAnOperand/getRightOperand: [IntegerLiteral] 5
|
|
# 96| getStmt: [AssignMulExpr] ... *= ...
|
|
# 96| getAnOperand/getLeftOperand: [GlobalVariableAccess] $global_var
|
|
# 96| getAnOperand/getRightOperand: [IntegerLiteral] 6
|
|
# 98| getStmt: [AssignExpr] ... = ...
|
|
# 98| getAnOperand/getLeftOperand: [ConstantAssignment] CONSTANT1
|
|
# 98| getAnOperand/getRightOperand: [IntegerLiteral] 5
|
|
# 99| getStmt: [AssignAddExpr] ... += ...
|
|
# 99| getAnOperand/getLeftOperand: [ConstantAssignment, ConstantReadAccess] CONSTANT2
|
|
# 99| getAnOperand/getRightOperand: [IntegerLiteral] 6
|
|
# 100| getStmt: [AssignLogicalOrExpr] ... ||= ...
|
|
# 100| getAnOperand/getLeftOperand: [ConstantAssignment, ConstantReadAccess] CONSTANT3
|
|
# 100| getAnOperand/getRightOperand: [IntegerLiteral] 7
|
|
# 101| getStmt: [AssignLogicalOrExpr] ... ||= ...
|
|
# 101| getAnOperand/getLeftOperand: [ConstantAssignment, ConstantReadAccess] MemberConstant
|
|
# 101| getScopeExpr: [ConstantReadAccess] Foo
|
|
# 101| getAnOperand/getRightOperand: [IntegerLiteral] 8
|
|
# 102| getStmt: [AssignLogicalOrExpr] ... ||= ...
|
|
# 102| getAnOperand/getLeftOperand: [ConstantAssignment, ConstantReadAccess] OtherConstant
|
|
# 102| getScopeExpr: [MethodCall] call to bar
|
|
# 102| getReceiver: [MethodCall] call to foo
|
|
# 102| getReceiver: [SelfVariableAccess] self
|
|
# 102| getArgument: [IntegerLiteral] 1
|
|
# 102| getAnOperand/getRightOperand: [IntegerLiteral] 7
|
|
# 103| getStmt: [AssignLogicalOrExpr] ... ||= ...
|
|
# 103| getAnOperand/getLeftOperand: [ConstantAssignment, ConstantReadAccess] CONSTANT4
|
|
# 103| getAnOperand/getRightOperand: [IntegerLiteral] 7
|
|
# 104| getStmt: [AssignExpr] ... = ...
|
|
# 104| getAnOperand/getLeftOperand: [DestructuredLhsExpr] (..., ...)
|
|
# 104| getElement: [ConstantAssignment] FOO
|
|
# 104| getElement: [ConstantAssignment] BAR
|
|
# 104| getElement: [ConstantAssignment] FOO
|
|
# 104| getScopeExpr: [LocalVariableAccess] foo
|
|
# 104| getAnOperand/getRightOperand: [ArrayLiteral] [...]
|
|
# 104| getElement: [IntegerLiteral] 1
|
|
# 104| getElement: [IntegerLiteral] 2
|
|
# 104| getElement: [IntegerLiteral] 3
|
|
# 106| getStmt: [DivExpr] ... / ...
|
|
# 106| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] foo
|
|
# 107| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 5
|
|
params/params.rb:
|
|
# 1| [Toplevel] params.rb
|
|
# 4| getStmt: [Method] identifier_method_params
|
|
# 4| getParameter: [SimpleParameter] foo
|
|
# 4| getDefiningAccess: [LocalVariableAccess] foo
|
|
# 4| getParameter: [SimpleParameter] bar
|
|
# 4| getDefiningAccess: [LocalVariableAccess] bar
|
|
# 4| getParameter: [SimpleParameter] baz
|
|
# 4| getDefiningAccess: [LocalVariableAccess] baz
|
|
# 8| getStmt: [AssignExpr] ... = ...
|
|
# 8| getAnOperand/getLeftOperand: [LocalVariableAccess] hash
|
|
# 8| getAnOperand/getRightOperand: [HashLiteral] {...}
|
|
# 9| getStmt: [MethodCall] call to each
|
|
# 9| getReceiver: [LocalVariableAccess] hash
|
|
# 9| getBlock: [DoBlock] do ... end
|
|
# 9| getParameter: [SimpleParameter] key
|
|
# 9| getDefiningAccess: [LocalVariableAccess] key
|
|
# 9| getParameter: [SimpleParameter] value
|
|
# 9| getDefiningAccess: [LocalVariableAccess] value
|
|
# 10| getStmt: [MethodCall] call to puts
|
|
# 10| getReceiver: [SelfVariableAccess] self
|
|
# 10| getArgument: [StringLiteral] "#{...} -> #{...}"
|
|
# 10| getComponent: [StringInterpolationComponent] #{...}
|
|
# 10| getStmt: [LocalVariableAccess] key
|
|
# 10| getComponent: [StringTextComponent] ->
|
|
# 10| getComponent: [StringInterpolationComponent] #{...}
|
|
# 10| getStmt: [LocalVariableAccess] value
|
|
# 14| getStmt: [AssignExpr] ... = ...
|
|
# 14| getAnOperand/getLeftOperand: [LocalVariableAccess] sum
|
|
# 14| getAnOperand/getRightOperand: [Lambda] -> { ... }
|
|
# 14| getParameter: [SimpleParameter] foo
|
|
# 14| getDefiningAccess: [LocalVariableAccess] foo
|
|
# 14| getParameter: [SimpleParameter] bar
|
|
# 14| getDefiningAccess: [LocalVariableAccess] bar
|
|
# 14| getStmt: [AddExpr] ... + ...
|
|
# 14| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] foo
|
|
# 14| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] bar
|
|
# 17| getStmt: [Method] destructured_method_param
|
|
# 17| getParameter: [DestructuredParameter] (..., ...)
|
|
# 17| getElement: [LocalVariableAccess] a
|
|
# 17| getElement: [LocalVariableAccess] b
|
|
# 17| getElement: [LocalVariableAccess] c
|
|
# 21| getStmt: [AssignExpr] ... = ...
|
|
# 21| getAnOperand/getLeftOperand: [LocalVariableAccess] array
|
|
# 21| getAnOperand/getRightOperand: [ArrayLiteral] [...]
|
|
# 22| getStmt: [MethodCall] call to each
|
|
# 22| getReceiver: [LocalVariableAccess] array
|
|
# 22| getBlock: [BraceBlock] { ... }
|
|
# 22| getParameter: [DestructuredParameter] (..., ...)
|
|
# 22| getElement: [LocalVariableAccess] a
|
|
# 22| getElement: [LocalVariableAccess] b
|
|
# 22| getStmt: [MethodCall] call to puts
|
|
# 22| getReceiver: [SelfVariableAccess] self
|
|
# 22| getArgument: [AddExpr] ... + ...
|
|
# 22| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 22| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] b
|
|
# 25| getStmt: [AssignExpr] ... = ...
|
|
# 25| getAnOperand/getLeftOperand: [LocalVariableAccess] sum_four_values
|
|
# 25| getAnOperand/getRightOperand: [Lambda] -> { ... }
|
|
# 25| getParameter: [DestructuredParameter] (..., ...)
|
|
# 25| getElement: [LocalVariableAccess] first
|
|
# 25| getElement: [LocalVariableAccess] second
|
|
# 25| getParameter: [DestructuredParameter] (..., ...)
|
|
# 25| getElement: [LocalVariableAccess] third
|
|
# 25| getElement: [LocalVariableAccess] fourth
|
|
# 26| getStmt: [AddExpr] ... + ...
|
|
# 26| getAnOperand/getLeftOperand/getReceiver: [AddExpr] ... + ...
|
|
# 26| getAnOperand/getLeftOperand/getReceiver: [AddExpr] ... + ...
|
|
# 26| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] first
|
|
# 26| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] second
|
|
# 26| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] third
|
|
# 26| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] fourth
|
|
# 30| getStmt: [Method] method_with_splat
|
|
# 30| getParameter: [SimpleParameter] wibble
|
|
# 30| getDefiningAccess: [LocalVariableAccess] wibble
|
|
# 30| getParameter: [SplatParameter] *splat
|
|
# 30| getDefiningAccess: [LocalVariableAccess] splat
|
|
# 30| getParameter: [HashSplatParameter] **double_splat
|
|
# 30| getDefiningAccess: [LocalVariableAccess] double_splat
|
|
# 34| getStmt: [MethodCall] call to each
|
|
# 34| getReceiver: [LocalVariableAccess] array
|
|
# 34| getBlock: [DoBlock] do ... end
|
|
# 34| getParameter: [SimpleParameter] val
|
|
# 34| getDefiningAccess: [LocalVariableAccess] val
|
|
# 34| getParameter: [SplatParameter] *splat
|
|
# 34| getDefiningAccess: [LocalVariableAccess] splat
|
|
# 34| getParameter: [HashSplatParameter] **double_splat
|
|
# 34| getDefiningAccess: [LocalVariableAccess] double_splat
|
|
# 38| getStmt: [AssignExpr] ... = ...
|
|
# 38| getAnOperand/getLeftOperand: [LocalVariableAccess] lambda_with_splats
|
|
# 38| getAnOperand/getRightOperand: [Lambda] -> { ... }
|
|
# 38| getParameter: [SimpleParameter] x
|
|
# 38| getDefiningAccess: [LocalVariableAccess] x
|
|
# 38| getParameter: [SplatParameter] *blah
|
|
# 38| getDefiningAccess: [LocalVariableAccess] blah
|
|
# 38| getParameter: [HashSplatParameter] **wibble
|
|
# 38| getDefiningAccess: [LocalVariableAccess] wibble
|
|
# 41| getStmt: [Method] method_with_keyword_params
|
|
# 41| getParameter: [SimpleParameter] x
|
|
# 41| getDefiningAccess: [LocalVariableAccess] x
|
|
# 41| getParameter: [KeywordParameter] foo
|
|
# 41| getDefiningAccess: [LocalVariableAccess] foo
|
|
# 41| getParameter: [KeywordParameter] bar
|
|
# 41| getDefiningAccess: [LocalVariableAccess] bar
|
|
# 41| getDefaultValue: [IntegerLiteral] 7
|
|
# 42| getStmt: [AddExpr] ... + ...
|
|
# 42| getAnOperand/getLeftOperand/getReceiver: [AddExpr] ... + ...
|
|
# 42| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 42| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] foo
|
|
# 42| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] bar
|
|
# 46| getStmt: [Method] use_block_with_keyword
|
|
# 46| getParameter: [BlockParameter] &block
|
|
# 46| getDefiningAccess: [LocalVariableAccess] block
|
|
# 47| getStmt: [MethodCall] call to puts
|
|
# 47| getReceiver: [SelfVariableAccess] self
|
|
# 47| getArgument: [MethodCall] call to call
|
|
# 47| getReceiver: [LocalVariableAccess] block
|
|
# 47| getArgument: [Pair] Pair
|
|
# 47| getKey: [SymbolLiteral] :bar
|
|
# 47| getComponent: [StringTextComponent] bar
|
|
# 47| getValue: [IntegerLiteral] 2
|
|
# 47| getArgument: [Pair] Pair
|
|
# 47| getKey: [SymbolLiteral] :foo
|
|
# 47| getComponent: [StringTextComponent] foo
|
|
# 47| getValue: [IntegerLiteral] 3
|
|
# 49| getStmt: [MethodCall] call to use_block_with_keyword
|
|
# 49| getReceiver: [SelfVariableAccess] self
|
|
# 49| getBlock: [DoBlock] do ... end
|
|
# 49| getParameter: [KeywordParameter] xx
|
|
# 49| getDefiningAccess: [LocalVariableAccess] xx
|
|
# 49| getParameter: [KeywordParameter] yy
|
|
# 49| getDefiningAccess: [LocalVariableAccess] yy
|
|
# 49| getDefaultValue: [IntegerLiteral] 100
|
|
# 50| getStmt: [AddExpr] ... + ...
|
|
# 50| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] xx
|
|
# 50| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] yy
|
|
# 53| getStmt: [AssignExpr] ... = ...
|
|
# 53| getAnOperand/getLeftOperand: [LocalVariableAccess] lambda_with_keyword_params
|
|
# 53| getAnOperand/getRightOperand: [Lambda] -> { ... }
|
|
# 53| getParameter: [SimpleParameter] x
|
|
# 53| getDefiningAccess: [LocalVariableAccess] x
|
|
# 53| getParameter: [KeywordParameter] y
|
|
# 53| getDefiningAccess: [LocalVariableAccess] y
|
|
# 53| getParameter: [KeywordParameter] z
|
|
# 53| getDefiningAccess: [LocalVariableAccess] z
|
|
# 53| getDefaultValue: [IntegerLiteral] 3
|
|
# 54| getStmt: [AddExpr] ... + ...
|
|
# 54| getAnOperand/getLeftOperand/getReceiver: [AddExpr] ... + ...
|
|
# 54| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 54| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] y
|
|
# 54| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] z
|
|
# 58| getStmt: [Method] method_with_optional_params
|
|
# 58| getParameter: [SimpleParameter] val1
|
|
# 58| getDefiningAccess: [LocalVariableAccess] val1
|
|
# 58| getParameter: [OptionalParameter] val2
|
|
# 58| getDefiningAccess: [LocalVariableAccess] val2
|
|
# 58| getDefaultValue: [IntegerLiteral] 0
|
|
# 58| getParameter: [OptionalParameter] val3
|
|
# 58| getDefiningAccess: [LocalVariableAccess] val3
|
|
# 58| getDefaultValue: [IntegerLiteral] 100
|
|
# 62| getStmt: [Method] use_block_with_optional
|
|
# 62| getParameter: [BlockParameter] &block
|
|
# 62| getDefiningAccess: [LocalVariableAccess] block
|
|
# 63| getStmt: [MethodCall] call to call
|
|
# 63| getReceiver: [LocalVariableAccess] block
|
|
# 63| getArgument: [StringLiteral] "Zeus"
|
|
# 63| getComponent: [StringTextComponent] Zeus
|
|
# 65| getStmt: [MethodCall] call to use_block_with_optional
|
|
# 65| getReceiver: [SelfVariableAccess] self
|
|
# 65| getBlock: [DoBlock] do ... end
|
|
# 65| getParameter: [SimpleParameter] name
|
|
# 65| getDefiningAccess: [LocalVariableAccess] name
|
|
# 65| getParameter: [OptionalParameter] age
|
|
# 65| getDefiningAccess: [LocalVariableAccess] age
|
|
# 65| getDefaultValue: [IntegerLiteral] 99
|
|
# 66| getStmt: [MethodCall] call to puts
|
|
# 66| getReceiver: [SelfVariableAccess] self
|
|
# 66| getArgument: [StringLiteral] "#{...} is #{...} years old"
|
|
# 66| getComponent: [StringInterpolationComponent] #{...}
|
|
# 66| getStmt: [LocalVariableAccess] name
|
|
# 66| getComponent: [StringTextComponent] is
|
|
# 66| getComponent: [StringInterpolationComponent] #{...}
|
|
# 66| getStmt: [LocalVariableAccess] age
|
|
# 66| getComponent: [StringTextComponent] years old
|
|
# 70| getStmt: [AssignExpr] ... = ...
|
|
# 70| getAnOperand/getLeftOperand: [LocalVariableAccess] lambda_with_optional_params
|
|
# 70| getAnOperand/getRightOperand: [Lambda] -> { ... }
|
|
# 70| getParameter: [SimpleParameter] a
|
|
# 70| getDefiningAccess: [LocalVariableAccess] a
|
|
# 70| getParameter: [OptionalParameter] b
|
|
# 70| getDefiningAccess: [LocalVariableAccess] b
|
|
# 70| getDefaultValue: [IntegerLiteral] 1000
|
|
# 70| getParameter: [OptionalParameter] c
|
|
# 70| getDefiningAccess: [LocalVariableAccess] c
|
|
# 70| getDefaultValue: [IntegerLiteral] 20
|
|
# 70| getStmt: [AddExpr] ... + ...
|
|
# 70| getAnOperand/getLeftOperand/getReceiver: [AddExpr] ... + ...
|
|
# 70| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] a
|
|
# 70| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] b
|
|
# 70| getAnOperand/getArgument/getRightOperand: [LocalVariableAccess] c
|
|
# 73| getStmt: [Method] method_with_nil_splat
|
|
# 73| getParameter: [SimpleParameter] wibble
|
|
# 73| getDefiningAccess: [LocalVariableAccess] wibble
|
|
# 73| getParameter: [HashSplatNilParameter] **nil
|
|
# 77| getStmt: [MethodCall] call to each
|
|
# 77| getReceiver: [LocalVariableAccess] array
|
|
# 77| getBlock: [DoBlock] do ... end
|
|
# 77| getParameter: [SimpleParameter] val
|
|
# 77| getDefiningAccess: [LocalVariableAccess] val
|
|
# 77| getParameter: [HashSplatNilParameter] **nil
|
|
# 81| getStmt: [Method] anonymous_block_parameter
|
|
# 81| getParameter: [SimpleParameter] array
|
|
# 81| getDefiningAccess: [LocalVariableAccess] array
|
|
# 81| getParameter: [BlockParameter] &
|
|
# 81| getDefiningAccess: [LocalVariableAccess] __synth__0
|
|
# 82| getStmt: [MethodCall] call to proc
|
|
# 82| getReceiver: [SelfVariableAccess] self
|
|
# 82| getArgument: [BlockArgument] &...
|
|
# 82| getValue: [LocalVariableAccess] __synth__0
|
|
# 83| getStmt: [MethodCall] call to each
|
|
# 83| getReceiver: [LocalVariableAccess] array
|
|
# 83| getArgument: [BlockArgument] &...
|
|
# 83| getValue: [LocalVariableAccess] __synth__0
|
|
# 86| getStmt: [MethodCall] call to run_block
|
|
# 86| getReceiver: [SelfVariableAccess] self
|
|
# 86| getBlock: [BraceBlock] { ... }
|
|
# 86| getParameter: [SimpleParameter] x
|
|
# 86| getDefiningAccess: [LocalVariableAccess] x
|
|
# 86| getLocalVariable: [LocalVariableAccess] y
|
|
# 86| getLocalVariable: [LocalVariableAccess] z
|
|
# 86| getStmt: [MethodCall] call to puts
|
|
# 86| getReceiver: [SelfVariableAccess] self
|
|
# 86| getArgument: [LocalVariableAccess] x
|
|
# 89| getStmt: [Method] anonymous_splat_parameter
|
|
# 89| getParameter: [SimpleParameter] array
|
|
# 89| getDefiningAccess: [LocalVariableAccess] array
|
|
# 89| getParameter: [SplatParameter] *
|
|
# 89| getDefiningAccess: [LocalVariableAccess] __synth__0
|
|
# 90| getStmt: [MethodCall] call to concat
|
|
# 90| getReceiver: [LocalVariableAccess] array
|
|
# 90| getArgument: [SplatExpr] * ...
|
|
# 90| getAnOperand/getOperand/getReceiver: [LocalVariableAccess] __synth__0
|
|
# 94| getStmt: [Method] anonymous_hash_splat_parameter
|
|
# 94| getParameter: [SimpleParameter] hash
|
|
# 94| getDefiningAccess: [LocalVariableAccess] hash
|
|
# 94| getParameter: [HashSplatParameter] **
|
|
# 94| getDefiningAccess: [LocalVariableAccess] __synth__0
|
|
# 95| getStmt: [MethodCall] call to merge
|
|
# 95| getReceiver: [LocalVariableAccess] hash
|
|
# 95| getArgument: [HashSplatExpr] ** ...
|
|
# 95| getAnOperand/getOperand/getReceiver: [LocalVariableAccess] __synth__0
|
|
# 98| getStmt: [ClassDeclaration] Sup
|
|
# 99| getStmt: [Method] m
|
|
# 99| getParameter: [SimpleParameter] x
|
|
# 99| getDefiningAccess: [LocalVariableAccess] x
|
|
# 99| getParameter: [SplatParameter] *rest
|
|
# 99| getDefiningAccess: [LocalVariableAccess] rest
|
|
# 99| getParameter: [KeywordParameter] k
|
|
# 99| getDefiningAccess: [LocalVariableAccess] k
|
|
# 99| getParameter: [HashSplatParameter] **kwargs
|
|
# 99| getDefiningAccess: [LocalVariableAccess] kwargs
|
|
# 100| getStmt: [MethodCall] call to print
|
|
# 100| getReceiver: [SelfVariableAccess] self
|
|
# 100| getArgument: [AddExpr] ... + ...
|
|
# 100| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] x
|
|
# 100| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 101| getStmt: [MethodCall] call to print
|
|
# 101| getReceiver: [SelfVariableAccess] self
|
|
# 101| getArgument: [AddExpr] ... + ...
|
|
# 101| getAnOperand/getLeftOperand/getReceiver: [LocalVariableAccess] k
|
|
# 101| getAnOperand/getArgument/getRightOperand: [IntegerLiteral] 1
|
|
# 105| getStmt: [ClassDeclaration] Sub
|
|
# 105| getSuperclassExpr: [ConstantReadAccess] Sup
|
|
# 106| getStmt: [Method] m
|
|
# 106| getParameter: [SimpleParameter] y
|
|
# 106| getDefiningAccess: [LocalVariableAccess] y
|
|
# 106| getParameter: [SplatParameter] *rest
|
|
# 106| getDefiningAccess: [LocalVariableAccess] rest
|
|
# 106| getParameter: [KeywordParameter] k
|
|
# 106| getDefiningAccess: [LocalVariableAccess] k
|
|
# 106| getParameter: [HashSplatParameter] **kwargs
|
|
# 106| getDefiningAccess: [LocalVariableAccess] kwargs
|
|
# 107| getStmt: [SuperCall] super call to m
|
|
# 107| getArgument: [LocalVariableAccess] y
|
|
# 107| getArgument: [SplatExpr] * ...
|
|
# 107| getAnOperand/getOperand/getReceiver: [LocalVariableAccess] rest
|
|
# 107| getArgument: [Pair] Pair
|
|
# 107| getKey: [SymbolLiteral] k
|
|
# 107| getValue: [LocalVariableAccess] k
|
|
# 107| getArgument: [HashSplatExpr] ** ...
|
|
# 107| getAnOperand/getOperand/getReceiver: [LocalVariableAccess] kwargs
|
|
# 111| getStmt: [MethodCall] call to m
|
|
# 111| getReceiver: [MethodCall] call to new
|
|
# 111| getReceiver: [ConstantReadAccess] Sub
|
|
# 111| getArgument: [IntegerLiteral] 42
|
|
# 111| getArgument: [Pair] Pair
|
|
# 111| getKey: [SymbolLiteral] :k
|
|
# 111| getComponent: [StringTextComponent] k
|
|
# 111| getValue: [IntegerLiteral] 22
|
|
erb/template.html.erb:
|
|
# 19| [Toplevel] template.html.erb
|
|
# 19| getStmt: [StringLiteral] "hello world"
|
|
# 19| getComponent: [StringTextComponent] hello world
|
|
# 25| getStmt: [AssignExpr] ... = ...
|
|
# 25| getAnOperand/getLeftOperand: [LocalVariableAccess] xs
|
|
# 25| getAnOperand/getRightOperand: [StringLiteral] ""
|
|
# 27| getStmt: [ForExpr] for ... in ...
|
|
# 27| getPattern: [LocalVariableAccess] x
|
|
# 27| getValue: [ArrayLiteral] [...]
|
|
# 27| getElement: [StringLiteral] "foo"
|
|
# 27| getComponent: [StringTextComponent] foo
|
|
# 27| getElement: [StringLiteral] "bar"
|
|
# 27| getComponent: [StringTextComponent] bar
|
|
# 27| getElement: [StringLiteral] "baz"
|
|
# 27| getComponent: [StringTextComponent] baz
|
|
# 27| getBody: [StmtSequence] do ...
|
|
# 28| getStmt: [AssignAddExpr] ... += ...
|
|
# 28| getAnOperand/getLeftOperand: [LocalVariableAccess] xs
|
|
# 28| getAnOperand/getRightOperand: [LocalVariableAccess] x
|
|
# 29| getStmt: [LocalVariableAccess] xs
|
|
gems/test.gemspec:
|
|
# 1| [Toplevel] test.gemspec
|
|
# 1| getStmt: [MethodCall] call to new
|
|
# 1| getReceiver: [ConstantReadAccess] Specification
|
|
# 1| getScopeExpr: [ConstantReadAccess] Gem
|
|
# 1| getBlock: [DoBlock] do ... end
|
|
# 1| getParameter: [SimpleParameter] s
|
|
# 1| getDefiningAccess: [LocalVariableAccess] s
|
|
# 2| getStmt: [AssignExpr] ... = ...
|
|
# 2| getAnOperand/getLeftOperand: [MethodCall] call to name
|
|
# 2| getReceiver: [LocalVariableAccess] s
|
|
# 2| getAnOperand/getRightOperand: [StringLiteral] "test"
|
|
# 2| getComponent: [StringTextComponent] test
|
|
# 3| getStmt: [AssignExpr] ... = ...
|
|
# 3| getAnOperand/getLeftOperand: [MethodCall] call to version
|
|
# 3| getReceiver: [LocalVariableAccess] s
|
|
# 3| getAnOperand/getRightOperand: [StringLiteral] "0.0.0"
|
|
# 3| getComponent: [StringTextComponent] 0.0.0
|
|
# 4| getStmt: [AssignExpr] ... = ...
|
|
# 4| getAnOperand/getLeftOperand: [MethodCall] call to summary
|
|
# 4| getReceiver: [LocalVariableAccess] s
|
|
# 4| getAnOperand/getRightOperand: [StringLiteral] "foo!"
|
|
# 4| getComponent: [StringTextComponent] foo!
|
|
# 5| getStmt: [AssignExpr] ... = ...
|
|
# 5| getAnOperand/getLeftOperand: [MethodCall] call to description
|
|
# 5| getReceiver: [LocalVariableAccess] s
|
|
# 5| getAnOperand/getRightOperand: [StringLiteral] "A test"
|
|
# 5| getComponent: [StringTextComponent] A test
|
|
# 6| getStmt: [AssignExpr] ... = ...
|
|
# 6| getAnOperand/getLeftOperand: [MethodCall] call to authors
|
|
# 6| getReceiver: [LocalVariableAccess] s
|
|
# 6| getAnOperand/getRightOperand: [ArrayLiteral] [...]
|
|
# 6| getElement: [StringLiteral] "Mona Lisa"
|
|
# 6| getComponent: [StringTextComponent] Mona Lisa
|
|
# 7| getStmt: [AssignExpr] ... = ...
|
|
# 7| getAnOperand/getLeftOperand: [MethodCall] call to email
|
|
# 7| getReceiver: [LocalVariableAccess] s
|
|
# 7| getAnOperand/getRightOperand: [StringLiteral] "mona@example.com"
|
|
# 7| getComponent: [StringTextComponent] mona@example.com
|
|
# 8| getStmt: [AssignExpr] ... = ...
|
|
# 8| getAnOperand/getLeftOperand: [MethodCall] call to files
|
|
# 8| getReceiver: [LocalVariableAccess] s
|
|
# 8| getAnOperand/getRightOperand: [ArrayLiteral] [...]
|
|
# 8| getElement: [StringLiteral] "lib/test.rb"
|
|
# 8| getComponent: [StringTextComponent] lib/test.rb
|
|
# 9| getStmt: [AssignExpr] ... = ...
|
|
# 9| getAnOperand/getLeftOperand: [MethodCall] call to homepage
|
|
# 9| getReceiver: [LocalVariableAccess] s
|
|
# 9| getAnOperand/getRightOperand: [StringLiteral] "https://github.com/github/cod..."
|
|
# 9| getComponent: [StringTextComponent] https://github.com/github/codeql-ruby
|
|
gems/lib/test.rb:
|
|
# 1| [Toplevel] test.rb
|
|
# 1| getStmt: [ClassDeclaration] Foo
|
|
# 2| getStmt: [SingletonMethod] greet
|
|
# 2| getObject: [SelfVariableAccess] self
|
|
# 3| getStmt: [MethodCall] call to puts
|
|
# 3| getReceiver: [SelfVariableAccess] self
|
|
# 3| getArgument: [StringLiteral] "Hello"
|
|
# 3| getComponent: [StringTextComponent] Hello
|
|
modules/toplevel.rb:
|
|
# 1| [Toplevel] toplevel.rb
|
|
# 1| getStmt: [MethodCall] call to puts
|
|
# 1| getReceiver: [SelfVariableAccess] self
|
|
# 1| getArgument: [StringLiteral] "world"
|
|
# 1| getComponent: [StringTextComponent] world
|
|
# 3| getStmt: [EndBlock] END { ... }
|
|
# 3| getStmt: [MethodCall] call to puts
|
|
# 3| getReceiver: [SelfVariableAccess] self
|
|
# 3| getArgument: [StringLiteral] "!!!"
|
|
# 3| getComponent: [StringTextComponent] !!!
|
|
# 5| getBeginBlock: [BeginBlock] BEGIN { ... }
|
|
# 5| getStmt: [MethodCall] call to puts
|
|
# 5| getReceiver: [SelfVariableAccess] self
|
|
# 5| getArgument: [StringLiteral] "hello"
|
|
# 5| getComponent: [StringTextComponent] hello
|