Ruby: Inline expectation should have space before $

ruby/ql/test/library-tests/dataflow/api-graphs/callbacks.rb

@@ -1,39 +1,39 @@
-Something.foo.withCallback do |a, b| #$ source=Member[Something].Method[foo].ReturnValue
-    a.something #$ source=Member[Something].Method[foo].ReturnValue.Method[withCallback].Argument[block].Argument[0].Method[something].ReturnValue
-    b.somethingElse #$ source=Member[Something].Method[foo].ReturnValue.Method[withCallback].Argument[block].Argument[1].Method[somethingElse].ReturnValue
-end #$ source=Member[Something].Method[foo].ReturnValue.Method[withCallback].ReturnValue
+Something.foo.withCallback do |a, b| # $ source=Member[Something].Method[foo].ReturnValue
+    a.something # $ source=Member[Something].Method[foo].ReturnValue.Method[withCallback].Argument[block].Argument[0].Method[something].ReturnValue
+    b.somethingElse # $ source=Member[Something].Method[foo].ReturnValue.Method[withCallback].Argument[block].Argument[1].Method[somethingElse].ReturnValue
+end # $ source=Member[Something].Method[foo].ReturnValue.Method[withCallback].ReturnValue
 
-Something.withNamedArg do |a:, b: nil| #$ source=Member[Something]
-    a.something #$ source=Member[Something].Method[withNamedArg].Argument[block].Parameter[a:].Method[something].ReturnValue
-    b.somethingElse #$ source=Member[Something].Method[withNamedArg].Argument[block].Parameter[b:].Method[somethingElse].ReturnValue
-end #$ source=Member[Something].Method[withNamedArg].ReturnValue
+Something.withNamedArg do |a:, b: nil| # $ source=Member[Something]
+    a.something # $ source=Member[Something].Method[withNamedArg].Argument[block].Parameter[a:].Method[something].ReturnValue
+    b.somethingElse # $ source=Member[Something].Method[withNamedArg].Argument[block].Parameter[b:].Method[somethingElse].ReturnValue
+end # $ source=Member[Something].Method[withNamedArg].ReturnValue
 
-Something.withLambda ->(a, b) { #$ source=Member[Something]
-    a.something #$ source=Member[Something].Method[withLambda].Argument[0].Parameter[0].Method[something].ReturnValue
-    b.something #$ source=Member[Something].Method[withLambda].Argument[0].Parameter[1].Method[something].ReturnValue
-} #$ source=Member[Something].Method[withLambda].ReturnValue
+Something.withLambda ->(a, b) { # $ source=Member[Something]
+    a.something # $ source=Member[Something].Method[withLambda].Argument[0].Parameter[0].Method[something].ReturnValue
+    b.something # $ source=Member[Something].Method[withLambda].Argument[0].Parameter[1].Method[something].ReturnValue
+} # $ source=Member[Something].Method[withLambda].ReturnValue
 
-Something.namedCallback( #$ source=Member[Something]
+Something.namedCallback( # $ source=Member[Something]
     onEvent: ->(a, b) {
-        a.something #$ source=Member[Something].Method[namedCallback].Argument[onEvent:].Parameter[0].Method[something].ReturnValue
-        b.something #$ source=Member[Something].Method[namedCallback].Argument[onEvent:].Parameter[1].Method[something].ReturnValue
+        a.something # $ source=Member[Something].Method[namedCallback].Argument[onEvent:].Parameter[0].Method[something].ReturnValue
+        b.something # $ source=Member[Something].Method[namedCallback].Argument[onEvent:].Parameter[1].Method[something].ReturnValue
     }
-) #$ source=Member[Something].Method[namedCallback].ReturnValue
+) # $ source=Member[Something].Method[namedCallback].ReturnValue
 
-Something.nestedCall1 do |a| #$ source=Member[Something]
-    a.nestedCall2 do |b:| #$ reachableFromSource=Member[Something].Method[nestedCall1].Argument[block].Parameter[0]
-        b.something #$ source=Member[Something].Method[nestedCall1].Argument[block].Parameter[0].Method[nestedCall2].Argument[block].Parameter[b:].Method[something].ReturnValue
-    end #$ source=Member[Something].Method[nestedCall1].Argument[block].Parameter[0].Method[nestedCall2].ReturnValue
-end #$ source=Member[Something].Method[nestedCall1].ReturnValue
+Something.nestedCall1 do |a| # $ source=Member[Something]
+    a.nestedCall2 do |b:| # $ reachableFromSource=Member[Something].Method[nestedCall1].Argument[block].Parameter[0]
+        b.something # $ source=Member[Something].Method[nestedCall1].Argument[block].Parameter[0].Method[nestedCall2].Argument[block].Parameter[b:].Method[something].ReturnValue
+    end # $ source=Member[Something].Method[nestedCall1].Argument[block].Parameter[0].Method[nestedCall2].ReturnValue
+end # $ source=Member[Something].Method[nestedCall1].ReturnValue
 
 def getCallback()
     ->(x) {
-        x.something #$ source=Member[Something].Method[indirectCallback].Argument[0].Parameter[0].Method[something].ReturnValue
+        x.something # $ source=Member[Something].Method[indirectCallback].Argument[0].Parameter[0].Method[something].ReturnValue
     }
 end
-Something.indirectCallback(getCallback()) #$ source=Member[Something].Method[indirectCallback].ReturnValue
+Something.indirectCallback(getCallback()) # $ source=Member[Something].Method[indirectCallback].ReturnValue
 
-Something.withMixed do |a, *args, b| #$ source=Member[Something]
-    a.something #$ source=Member[Something].Method[withMixed].Argument[block].Parameter[0].Method[something].ReturnValue
+Something.withMixed do |a, *args, b| # $ source=Member[Something]
+    a.something # $ source=Member[Something].Method[withMixed].Argument[block].Parameter[0].Method[something].ReturnValue
     # b.something # not currently handled correctly
-end #$ source=Member[Something].Method[withMixed].ReturnValue
+end # $ source=Member[Something].Method[withMixed].ReturnValue

ruby/ql/test/library-tests/dataflow/api-graphs/test1.rb

@@ -1,34 +1,34 @@
-MyModule #$ source=Member[MyModule]
-print MyModule.foo #$ source=Member[MyModule].Method[foo].ReturnValue
-Kernel.print(e) #$ source=Member[Kernel].Method[print].ReturnValue sink=Member[Kernel].Method[print].Argument[0]
-Object::Kernel #$ source=Member[Kernel]
-Object::Kernel.print(e)  #$ source=Member[Kernel].Method[print].ReturnValue
+MyModule # $ source=Member[MyModule]
+print MyModule.foo # $ source=Member[MyModule].Method[foo].ReturnValue
+Kernel.print(e) # $ source=Member[Kernel].Method[print].ReturnValue sink=Member[Kernel].Method[print].Argument[0]
+Object::Kernel # $ source=Member[Kernel]
+Object::Kernel.print(e)  # $ source=Member[Kernel].Method[print].ReturnValue
 begin
-    print MyModule.bar #$ source=Member[MyModule].Method[bar].ReturnValue
-    raise AttributeError #$ source=Member[AttributeError]
-rescue AttributeError => e #$ source=Member[AttributeError]
-    Kernel.print(e)  #$ source=Member[Kernel].Method[print].ReturnValue
+    print MyModule.bar # $ source=Member[MyModule].Method[bar].ReturnValue
+    raise AttributeError # $ source=Member[AttributeError]
+rescue AttributeError => e # $ source=Member[AttributeError]
+    Kernel.print(e)  # $ source=Member[Kernel].Method[print].ReturnValue
 end
-Unknown.new.run #$ source=Member[Unknown].Method[new].ReturnValue.Method[run].ReturnValue
-Foo::Bar::Baz #$ source=Member[Foo].Member[Bar].Member[Baz]
+Unknown.new.run # $ source=Member[Unknown].Method[new].ReturnValue.Method[run].ReturnValue
+Foo::Bar::Baz # $ source=Member[Foo].Member[Bar].Member[Baz]
 
-Const = [1, 2, 3] #$ source=Member[Array].MethodBracket.ReturnValue
-Const.each do |c| #$ source=Member[Const]
-    puts c #$ reachableFromSource=Member[Const].Method[each].Argument[block].Parameter[0] reachableFromSource=Member[Const].Element[any]
-end #$ source=Member[Const].Method[each].ReturnValue sink=Member[Const].Method[each].Argument[block]
+Const = [1, 2, 3] # $ source=Member[Array].MethodBracket.ReturnValue
+Const.each do |c| # $ source=Member[Const]
+    puts c # $ reachableFromSource=Member[Const].Method[each].Argument[block].Parameter[0] reachableFromSource=Member[Const].Element[any]
+end # $ source=Member[Const].Method[each].ReturnValue sink=Member[Const].Method[each].Argument[block]
 
-foo = Foo #$ source=Member[Foo]
-foo::Bar::Baz #$ source=Member[Foo].Member[Bar].Member[Baz]
+foo = Foo # $ source=Member[Foo]
+foo::Bar::Baz # $ source=Member[Foo].Member[Bar].Member[Baz]
 
-FooAlias = Foo #$ source=Member[Foo]
-FooAlias::Bar::Baz #$ source=Member[Foo].Member[Bar].Member[Baz] source=Member[FooAlias].Member[Bar].Member[Baz]
+FooAlias = Foo # $ source=Member[Foo]
+FooAlias::Bar::Baz # $ source=Member[Foo].Member[Bar].Member[Baz] source=Member[FooAlias].Member[Bar].Member[Baz]
 
 module Outer
     module Inner
     end
 end
 
-Outer::Inner.foo #$ source=Member[Outer].Member[Inner].Method[foo].ReturnValue
+Outer::Inner.foo # $ source=Member[Outer].Member[Inner].Method[foo].ReturnValue
 
 module M1
     class C1
@@ -40,36 +40,36 @@ module M1
     end
 end
 
-class C2 < M1::C1 #$ source=Member[M1].Member[C1]
+class C2 < M1::C1 # $ source=Member[M1].Member[C1]
 end
 
 module M2
-    class C3 < M1::C1 #$ source=Member[M1].Member[C1]
+    class C3 < M1::C1 # $ source=Member[M1].Member[C1]
     end
 
-    class C4 < C2 #$ source=Member[C2]
+    class C4 < C2 # $ source=Member[C2]
     end
 end
 
-C2 #$ source=Member[C2] reachableFromSource=Member[M1].Member[C1]
-M2::C3 #$ source=Member[M2].Member[C3] reachableFromSource=Member[M1].Member[C1]
-M2::C4 #$ source=Member[M2].Member[C4] reachableFromSource=Member[C2] reachableFromSource=Member[M1].Member[C1]
+C2 # $ source=Member[C2] reachableFromSource=Member[M1].Member[C1]
+M2::C3 # $ source=Member[M2].Member[C3] reachableFromSource=Member[M1].Member[C1]
+M2::C4 # $ source=Member[M2].Member[C4] reachableFromSource=Member[C2] reachableFromSource=Member[M1].Member[C1]
 
-M1::C1.m #$ source=Member[M1].Member[C1].Method[m].ReturnValue
-M2::C3.m #$ source=Member[M2].Member[C3].Method[m].ReturnValue source=Member[M1].Member[C1].Method[m].ReturnValue
+M1::C1.m # $ source=Member[M1].Member[C1].Method[m].ReturnValue
+M2::C3.m # $ source=Member[M2].Member[C3].Method[m].ReturnValue source=Member[M1].Member[C1].Method[m].ReturnValue
 
-M1::C1.new.m #$ source=Member[M1].Member[C1].Method[new].ReturnValue.Method[m].ReturnValue
-M2::C3.new.m #$ source=Member[M2].Member[C3].Method[new].ReturnValue.Method[m].ReturnValue
+M1::C1.new.m # $ source=Member[M1].Member[C1].Method[new].ReturnValue.Method[m].ReturnValue
+M2::C3.new.m # $ source=Member[M2].Member[C3].Method[new].ReturnValue.Method[m].ReturnValue
 
-Foo.foo(a,b:c) #$ source=Member[Foo].Method[foo].ReturnValue sink=Member[Foo].Method[foo].Argument[0] sink=Member[Foo].Method[foo].Argument[b:]
+Foo.foo(a,b:c) # $ source=Member[Foo].Method[foo].ReturnValue sink=Member[Foo].Method[foo].Argument[0] sink=Member[Foo].Method[foo].Argument[b:]
 
 def userDefinedFunction(x, y)
     x.noApiGraph(y)
-    x.customEntryPointCall(y) #$ call=EntryPoint[CustomEntryPointCall] source=EntryPoint[CustomEntryPointCall].ReturnValue sink=EntryPoint[CustomEntryPointCall].Parameter[0]
-    x.customEntryPointUse(y) #$ source=EntryPoint[CustomEntryPointUse]
+    x.customEntryPointCall(y) # $ call=EntryPoint[CustomEntryPointCall] source=EntryPoint[CustomEntryPointCall].ReturnValue sink=EntryPoint[CustomEntryPointCall].Parameter[0]
+    x.customEntryPointUse(y) # $ source=EntryPoint[CustomEntryPointUse]
 end
 
-array = [A::B::C] #$ source=Member[Array].MethodBracket.ReturnValue
-array[0].m #$ source=Member[A].Member[B].Member[C].Method[m].ReturnValue source=Member[Array].MethodBracket.ReturnValue.Element[0].Method[m].ReturnValue
+array = [A::B::C] # $ source=Member[Array].MethodBracket.ReturnValue
+array[0].m # $ source=Member[A].Member[B].Member[C].Method[m].ReturnValue source=Member[Array].MethodBracket.ReturnValue.Element[0].Method[m].ReturnValue
 
-A::B::C[0] #$ source=Member[A].Member[B].Member[C].Element[0]
+A::B::C[0] # $ source=Member[A].Member[B].Member[C].Element[0]

ruby/ql/test/query-tests/variables/DeadStoreOfLocal/DeadStoreOfLocal.rb

@@ -1,5 +1,5 @@
 def test_basic(x)
-    y = x  #$ Alert
+    y = x  # $ Alert
     y = x + 2
     return y
 end
@@ -27,7 +27,7 @@ class Sup
         print(x + 1)
     end
 end
-  
+
 class Sub < Sup
     def m(y)
         y = 3  # OK - the call to `super` sees the value of `y``
@@ -39,7 +39,7 @@ def do_twice
     yield
     yield
 end
-    
+
 def get_done_twice x
     do_twice do
         print x
@@ -52,7 +52,7 @@ def retry_once
 rescue
     yield
 end
-    
+
 def get_retried x
     retry_once do
         print x
@@ -63,4 +63,4 @@ def get_retried x
             end
         end
     end
-end
+end

ruby/ql/test/query-tests/variables/UninitializedLocal/UninitializedLocal.rb

@@ -9,7 +9,7 @@ def foo
       m # reads local variable m
   else
   end
-  m.strip  #$ Alert
+  m.strip  # $ Alert
   m2 # undefined local variable or method 'm2' for main (NameError)
 end
 
@@ -31,7 +31,7 @@ def test_guards
     b&.strip  # OK - safe navigation
     b.strip if b  # OK
     b.close if b && !b.closed # OK
-    b.blowup if b || !b.blownup #$ Alert
+    b.blowup if b || !b.blownup # $ Alert
 
     if false
         c = "0"
@@ -64,7 +64,7 @@ def test_loop
             a = 0
         else
             set_a
-        end   
+        end
     end until a  # OK
     a.strip  # OK - given previous until
 end
@@ -73,5 +73,5 @@ def test_for
     for i in ["foo", "bar"]  # OK - since 0..10 cannot raise
         puts i.strip
     end
-    i.strip  #$ SPURIOUS: Alert
-end
+    i.strip  # $ SPURIOUS: Alert
+end