mirror of
https://github.com/github/codeql.git
synced 2025-12-18 09:43:15 +01:00
524 lines
10 KiB
Ruby
524 lines
10 KiB
Ruby
def m0(i)
|
|
a = *source(0)
|
|
sink(a[0]) # $ hasValueFlow=0
|
|
sink(a[1])
|
|
sink(a[i]) # $ hasValueFlow=0
|
|
end
|
|
|
|
def m1(i)
|
|
a = [0, source(1), 2]
|
|
sink(a[0])
|
|
sink(a[1]) # $ hasValueFlow=1
|
|
sink(a[2])
|
|
sink(a[i]) # $ hasValueFlow=1
|
|
end
|
|
|
|
def m2(i)
|
|
a = Array.new(1, source(2.1))
|
|
sink(a[0]) # $ hasValueFlow=2.1
|
|
sink(a[i]) # $ hasValueFlow=2.1
|
|
|
|
b = Array.new(a)
|
|
sink(b[0]) # $ hasValueFlow=2.1
|
|
sink(b[i]) # $ hasValueFlow=2.1
|
|
|
|
c = Array.new(1) do |x|
|
|
source(2.2)
|
|
end
|
|
sink(c[0]) # $ hasValueFlow=2.2
|
|
sink(c[i]) # $ hasValueFlow=2.2
|
|
end
|
|
|
|
def m3
|
|
a = [source(3), 1]
|
|
b = Array.try_convert(a)
|
|
sink(b[0]) # $ hasValueFlow=3
|
|
sink(b[1])
|
|
end
|
|
|
|
def m4
|
|
a = [source(4.1), 1]
|
|
b = [2, 3, source(4.2)]
|
|
c = a & b
|
|
sink(c[0]) # $ hasValueFlow=4.1 $ hasValueFlow=4.2
|
|
sink(c[1]) # $ hasValueFlow=4.1 $ hasValueFlow=4.2
|
|
end
|
|
|
|
def m5
|
|
a = [source(5), 1]
|
|
b = a * 3
|
|
sink(b[0]) # $ hasValueFlow=5
|
|
sink(b[1]) # $ hasValueFlow=5
|
|
end
|
|
|
|
def m6
|
|
a = [source(6.1), 1]
|
|
b = [2, source(6.2)]
|
|
c = a + b
|
|
sink(c[0]) # $ hasValueFlow=6.1 $ hasValueFlow=6.2
|
|
sink(c[1]) # $ hasValueFlow=6.2
|
|
end
|
|
|
|
def m7
|
|
a = [source(7.1), 1]
|
|
b = [2, source(7.2)]
|
|
c = a - b
|
|
sink(c[0]) # $ hasValueFlow=7.1
|
|
sink(c[1]) # $ hasValueFlow=7.1
|
|
end
|
|
|
|
def m8
|
|
a = [source(8.1), 1]
|
|
b = a << source(8.2)
|
|
sink(b[0]) # $ hasValueFlow=8.1 $ hasValueFlow=8.2
|
|
sink(b[1]) # $ hasValueFlow=8.2
|
|
end
|
|
|
|
def m9(i)
|
|
a = [0, source(9), 2]
|
|
b, c, d = a
|
|
sink(b)
|
|
sink(c) # $ hasValueFlow=9
|
|
sink(d)
|
|
end
|
|
|
|
def m10(i)
|
|
a = [0, source(10), 2]
|
|
b = a[0, 2]
|
|
sink(b[0]) # $ hasValueFlow=10
|
|
sink(b[1]) # $ hasValueFlow=10
|
|
sink(b[i]) # $ hasValueFlow=10
|
|
end
|
|
|
|
def m11(i)
|
|
a = [0, source(11), 2]
|
|
b = a[0..2]
|
|
sink(b[0]) # $ hasValueFlow=11
|
|
sink(b[1]) # $ hasValueFlow=11
|
|
sink(b[i]) # $ hasValueFlow=11
|
|
end
|
|
|
|
def m12(i)
|
|
a = [0, 1]
|
|
a[0, 1] = source(12)
|
|
sink(a[0]) # $ hasValueFlow=12
|
|
sink(a[1]) # $ hasValueFlow=12
|
|
sink(a[i]) # $ hasValueFlow=12
|
|
end
|
|
|
|
def m13(i)
|
|
a = [0, 1]
|
|
a[0, 1] = [0, source(13), 2]
|
|
sink(a[0]) # $ hasValueFlow=13
|
|
sink(a[1]) # $ hasValueFlow=13
|
|
sink(a[i]) # $ hasValueFlow=13
|
|
end
|
|
|
|
def m14(i)
|
|
a = [0, 1]
|
|
a[0..1] = source(14)
|
|
sink(a[0]) # $ hasValueFlow=14
|
|
sink(a[1]) # $ hasValueFlow=14
|
|
sink(a[i]) # $ hasValueFlow=14
|
|
end
|
|
|
|
def m15(i)
|
|
a = [0, 1]
|
|
a[0..1] = [0, source(15), 2]
|
|
sink(a[0]) # $ hasValueFlow=15
|
|
sink(a[1]) # $ hasValueFlow=15
|
|
sink(a[i]) # $ hasValueFlow=15
|
|
end
|
|
|
|
def m16
|
|
a = [0, 1, source(16)]
|
|
a.all? do |x|
|
|
sink x # $ hasValueFlow=16
|
|
end
|
|
end
|
|
|
|
def m17
|
|
a = [0, 1, source(17)]
|
|
a.any? do |x|
|
|
sink x # $ hasValueFlow=17
|
|
end
|
|
end
|
|
|
|
def m18
|
|
a = ["a", 0]
|
|
b = ["b", 1]
|
|
c = ["c", source(18)]
|
|
d = [a, b, c]
|
|
sink (d.assoc("a")[0]) # $ hasValueFlow=18
|
|
sink (d.assoc("c")[0]) # $ hasValueFlow=18
|
|
end
|
|
|
|
def m19(i)
|
|
a = [0, source(19), 2]
|
|
sink(a.at(0))
|
|
sink(a.at(1)) # $ hasValueFlow=19
|
|
sink(a.at(2))
|
|
sink(a.at(i)) # $ hasValueFlow=19
|
|
end
|
|
|
|
def m20
|
|
a = [0, 1, source(20)]
|
|
b = a.bsearch do |x|
|
|
sink x # $ hasValueFlow=20
|
|
end
|
|
sink b # $ hasValueFlow=20
|
|
end
|
|
|
|
def m21
|
|
a = [0, 1, source(21)]
|
|
b = a.bsearch_index do |x|
|
|
sink x # $ hasValueFlow=21
|
|
end
|
|
sink b
|
|
end
|
|
|
|
def m22
|
|
a = [0, 1, source(22)]
|
|
a.clear()
|
|
sink(a[2])
|
|
end
|
|
|
|
def m23
|
|
a = [0, 1, source(23)]
|
|
b = a.collect do |x|
|
|
sink x # $ hasValueFlow=23
|
|
x
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=23
|
|
end
|
|
|
|
def m24
|
|
a = [0, 1, source(24)]
|
|
b = a.collect_concat do |x|
|
|
sink x # $ hasValueFlow=24
|
|
[x, x]
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=24
|
|
end
|
|
|
|
def m25
|
|
a = [0, 1, source(25)]
|
|
a.combination(1) do |x|
|
|
sink(x[0]) # $ hasValueFlow=25
|
|
end
|
|
end
|
|
|
|
def m26
|
|
a = [0, 1, source(26)]
|
|
b = a.compact
|
|
sink(b[0]) # $ hasValueFlow=26
|
|
end
|
|
|
|
def m27
|
|
a = [0, 1, source(27.1)]
|
|
b = [0, 1, source(27.2)]
|
|
a.concat(b)
|
|
sink(a[0]) # $ hasValueFlow=27.2
|
|
sink(a[2]) # $ hasValueFlow=27.1 $ hasValueFlow=27.2
|
|
end
|
|
|
|
def m28
|
|
a = [0, 1, source(28)]
|
|
a.count do |x|
|
|
sink x # $ hasValueFlow=28
|
|
end
|
|
end
|
|
|
|
def m29
|
|
a = [0, 1, source(29)]
|
|
a.cycle(2) do |x|
|
|
sink x # $ hasValueFlow=29
|
|
end
|
|
end
|
|
|
|
def m30
|
|
a = [0, 1, source(30.1)]
|
|
b = a.delete(2) { source(30.2) }
|
|
sink b # $ hasValueFlow=30.1 $ hasValueFlow=30.2
|
|
end
|
|
|
|
def m31
|
|
a = [0, 1, source(31)]
|
|
b = a.delete_at(2)
|
|
sink b # $ hasValueFlow=31
|
|
end
|
|
|
|
def m32
|
|
a = [0, 1, source(32)]
|
|
b = a.delete_if do |x|
|
|
sink x # $ hasValueFlow=32
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=32
|
|
end
|
|
|
|
def m33
|
|
a = [0, 1, source(33)]
|
|
b = a.difference([1])
|
|
sink(b[0]) # $ hasValueFlow=33
|
|
end
|
|
|
|
def m34(i)
|
|
a = [0, 1, source(34.1), [0, source(34.2)]]
|
|
sink(a.dig(0))
|
|
sink(a.dig(2)) # $ hasValueFlow=34.1
|
|
sink(a.dig(i)) # $ hasValueFlow=34.1
|
|
sink(a.dig(3,0))
|
|
sink(a.dig(3,1)) # $ hasValueFlow=34.2
|
|
end
|
|
|
|
def m35
|
|
a = [0, 1, source(35.1)]
|
|
b = a.detect(-> { source(35.2) }) do |x|
|
|
sink x # $ hasValueFlow=35.1
|
|
end
|
|
sink b # $ hasValueFlow=35.1 $ hasValueFlow=35.2
|
|
end
|
|
|
|
def m36(i)
|
|
a = [0, 1, source(36.1), source(36.2)]
|
|
b = a.drop(i)
|
|
sink(b[0]) # $ hasValueFlow=36.1 # $ hasValueFlow=36.2
|
|
b = a.drop(1)
|
|
sink(b[0])
|
|
sink(b[1]) # $ hasValueFlow=36.1
|
|
sink(b[i]) # $ hasValueFlow=36.1 # $ hasValueFlow=36.2
|
|
a[i] = source(36.3)
|
|
b = a.drop(1)
|
|
sink(b[1]) # $ hasValueFlow=36.1 # $ hasValueFlow=36.3
|
|
c = b.drop(100)
|
|
sink(c[1]) # $ hasValueFlow=36.3
|
|
end
|
|
|
|
def m37
|
|
a = [0, 1, source(37.1), source(37.2)]
|
|
b = a.drop_while do |x|
|
|
sink x # $ hasValueFlow=37.1 # $ hasValueFlow=37.2
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=37.1 # $ hasValueFlow=37.2
|
|
end
|
|
|
|
def m38
|
|
a = [0, 1, source(38)]
|
|
b = a.each do |x|
|
|
sink x # $ hasValueFlow=38
|
|
end
|
|
sink(b[2]) # $ hasValueFlow=38
|
|
end
|
|
|
|
def m39
|
|
a = [0, 1, source(39)]
|
|
b = for x in a # desugars to an `each` call
|
|
sink x # $ hasValueFlow=39
|
|
end
|
|
sink x # $ hasValueFlow=39
|
|
sink(b[2]) # $ hasValueFlow=39
|
|
end
|
|
|
|
def m40
|
|
a = [0, 1, source(40)]
|
|
a.each_cons(2) do |x|
|
|
sink (x[0]) # $ hasValueFlow=40
|
|
end
|
|
end
|
|
|
|
def m41
|
|
a = [0, 1, source(41)]
|
|
b = a.each_entry do |x|
|
|
sink x # $ hasValueFlow=41
|
|
end
|
|
sink(b[2]) # $ hasValueFlow=41
|
|
end
|
|
|
|
def m42
|
|
a = [0, 1, source(42)]
|
|
b = a.each_index do |x|
|
|
sink x
|
|
end
|
|
sink(b[2]) # $ hasValueFlow=42
|
|
end
|
|
|
|
def m43
|
|
a = [0, 1, 2, source(43)]
|
|
a.each_slice(1) do |x|
|
|
sink(x[0]) # $ hasValueFlow=43
|
|
end
|
|
end
|
|
|
|
def m44
|
|
a = [0, 1, 2, source(44)]
|
|
b = a.each_with_index do |x,i|
|
|
sink(x) # $ hasValueFlow=44
|
|
sink(i)
|
|
end
|
|
sink(b[3]) # $ hasValueFlow=44
|
|
end
|
|
|
|
def m45
|
|
a = [0, 1, 2, source(45.1)]
|
|
b = a.each_with_object(source(45.2)) do |x,a|
|
|
sink(x) # $ hasValueFlow=45.1
|
|
sink(a) # $ hasValueFlow=45.2
|
|
end
|
|
sink(b) # $ hasValueFlow=45.2
|
|
end
|
|
|
|
def m46(i)
|
|
a = [0, 1, 2, source(46.1)]
|
|
b = a.fetch(source(46.2)) do |x|
|
|
sink(x) # $ hasValueFlow=46.2
|
|
end
|
|
sink(b) # $ hasValueFlow=46.1
|
|
end
|
|
|
|
def m47
|
|
a = [0, 1, 2, source(47.1)]
|
|
a.fill(source(47.2), 1, 1)
|
|
sink(a[3]) # $ hasValueFlow=47.1 $ hasValueFlow=47.2
|
|
a.fill(source(47.3))
|
|
sink(a[0]) # $ hasValueFlow=47.3
|
|
a.fill do |i|
|
|
source(47.4)
|
|
end
|
|
sink(a[0]) # $ hasValueFlow=47.4
|
|
a.fill(2) do |i|
|
|
source(47.5)
|
|
end
|
|
sink(a[0]) # $ hasValueFlow=47.4 $ hasValueFlow=47.5
|
|
end
|
|
|
|
def m48
|
|
a = [0, 1, 2, source(48)]
|
|
b = a.filter do |x|
|
|
sink(x) # $ hasValueFlow=48
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=48
|
|
end
|
|
|
|
def m49
|
|
a = [0, 1, 2, source(49)]
|
|
b = a.filter_map do |x|
|
|
sink(x) # $ hasValueFlow=49
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=49
|
|
end
|
|
|
|
def m50
|
|
a = [0, 1, 2, source(50)]
|
|
b = a.filter! do |x|
|
|
sink(x) # $ hasValueFlow=50
|
|
x > 2
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=50
|
|
end
|
|
|
|
def m51
|
|
a = [0, 1, 2, source(51.1)]
|
|
b = a.find(-> { source(51.2) }) do |x|
|
|
sink(x) # $ hasValueFlow=51.1
|
|
end
|
|
sink(b) # $ hasValueFlow=51.1 $ hasValueFlow=51.2
|
|
end
|
|
|
|
def m52
|
|
a = [0, 1, 2, source(52)]
|
|
b = a.find_all do |x|
|
|
sink(x) # $ hasValueFlow=52
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=52
|
|
end
|
|
|
|
def m53
|
|
a = [0, 1, 2, source(53)]
|
|
a.find_index do |x|
|
|
sink(x) # $ hasValueFlow=53
|
|
end
|
|
end
|
|
|
|
def m54(i)
|
|
a = [source(54.1), 1, 2, source(54.2)]
|
|
a[i] = source(54.3)
|
|
sink(a.first) # $ hasValueFlow=54.1 $ hasValueFlow=54.3
|
|
b = a.first(2)
|
|
sink(b[0]) # $ hasValueFlow=54.1 $ hasValueFlow=54.3
|
|
sink(b[4]) # $ hasValueFlow=54.3
|
|
c = a.first(i)
|
|
sink(c[0]) # $ hasValueFlow=54.1 $ hasValueFlow=54.3
|
|
sink(c[3]) # $ hasValueFlow=54.2 $ hasValueFlow=54.3
|
|
end
|
|
|
|
def m55
|
|
a = [0, 1, 2, source(55.1)]
|
|
b = a.flat_map do |x|
|
|
sink(x) # $ hasValueFlow=55.1
|
|
[x, source(55.2)]
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=55.1 $ hasValueFlow=55.2
|
|
end
|
|
|
|
def m56
|
|
a = [0, 1, [2, source(56)]]
|
|
b = a.flatten
|
|
sink(b[0]) # $ hasValueFlow=56
|
|
end
|
|
|
|
def m57
|
|
a = [0, 1, [2, source(57)]]
|
|
sink(a[2][1]) # $ hasValueFlow=57
|
|
a.flatten!
|
|
sink(a[0]) # $ hasValueFlow=57
|
|
sink(a[2][1]) # $ SPURIOUS: hasValueFlow=57
|
|
end
|
|
|
|
def m58
|
|
a = [0, 1, 2, source(58.1)]
|
|
b = a.grep(/.*/)
|
|
sink(b[0]) # $ hasValueFlow=58.1
|
|
b = a.grep(/.*/) do |x|
|
|
sink x # $ hasValueFlow=58.1
|
|
source(58.2)
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=58.2
|
|
end
|
|
|
|
def m59
|
|
a = [0, 1, 2, source(59.1)]
|
|
b = a.grep_v(/A/)
|
|
sink(b[0]) # $ hasValueFlow=59.1
|
|
b = a.grep_v(/A/) do |x|
|
|
sink x # $ hasValueFlow=59.1
|
|
source(59.2)
|
|
end
|
|
sink(b[0]) # $ hasValueFlow=59.2
|
|
end
|
|
|
|
def m60
|
|
a = [0, 1, 2, source(60)]
|
|
a.index do |x|
|
|
sink x # $ hasValueFlow=60
|
|
end
|
|
end
|
|
|
|
def m61
|
|
a = [0, 1, 2, source(61.1)]
|
|
a.replace([source(61.2)])
|
|
sink(a[0]) # $ hasValueFlow=61.2
|
|
end
|
|
|
|
|
|
# TODO: assign appropriate number when reached in the alphabetical ordering
|
|
def m2600
|
|
a = [0, 1, source(2600.1)]
|
|
a.prepend(2, 3, source(2600.2))
|
|
sink(a[0])
|
|
sink(a[1])
|
|
sink(a[2]) # $ hasValueFlow=2600.2
|
|
sink(a[3])
|
|
sink(a[4])
|
|
sink(a[5]) # $ hasValueFlow=2600.1
|
|
end
|