Merge pull request #100 from github/call_ast

Add AST classes and tests for method calls

Author: nickrolfe

Cargo.lock

@@ -10,7 +10,7 @@ edition = "2018"
 flate2 = "1.0"
 node-types = { path = "../node-types" }
 tree-sitter = "0.17"
-tree-sitter-ruby = { git = "https://github.com/tree-sitter/tree-sitter-ruby.git", rev = "5021a6a6eda24e10f954dcfec00e7a7adafba8ba" }
+tree-sitter-ruby = { git = "https://github.com/tree-sitter/tree-sitter-ruby.git", rev = "454f90628d1d14d0953b3be78bdb9a09f7a5bfd7" }
 clap = "2.33"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", features = ["env-filter"] }

extractor/Cargo.toml

@@ -10,4 +10,4 @@ edition = "2018"
 node-types = { path = "../node-types" }
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", features = ["env-filter"] }
-tree-sitter-ruby = { git = "https://github.com/tree-sitter/tree-sitter-ruby.git", rev = "5021a6a6eda24e10f954dcfec00e7a7adafba8ba" }
+tree-sitter-ruby = { git = "https://github.com/tree-sitter/tree-sitter-ruby.git", rev = "454f90628d1d14d0953b3be78bdb9a09f7a5bfd7" }

generator/Cargo.toml

@@ -1,4 +1,5 @@
 import codeql.Locations
+import ast.Call
 import ast.Control
 import ast.Expr
 import ast.Method

ql/src/codeql_ruby/AST.qll

@@ -0,0 +1,178 @@
+private import codeql_ruby.AST
+private import internal.Call
+
+/**
+ * A call.
+ */
+class Call extends Expr {
+  override Call::Range range;
+
+  override string getAPrimaryQlClass() { result = "Call" }
+
+  final override string toString() { result = "call to " + this.getMethodName() }
+
+  /**
+   * Gets the receiver of this call, if any. For example:
+   * ```rb
+   * foo.bar
+   * baz()
+   * ```
+   * The result for the call to `bar` is the `Expr` for `foo`, while the call
+   * to `baz` has no result.
+   */
+  final Expr getReceiver() { result = range.getReceiver() }
+
+  /**
+   * Gets the name of the method being called. For example, in:
+   * ```rb
+   * foo.bar x, y
+   * ```
+   * the result is `"bar"`.
+   *
+   * N.B. in the following example, where the method name is a scope
+   * resolution, the result is the name being resolved, i.e. `"bar"`. Use
+   * `getMethodScopeResolution` to get the complete `ScopeResolution`.
+   * ```rb
+   * Foo::bar x, y
+   * ```
+   */
+  final string getMethodName() { result = range.getMethodName() }
+
+  /**
+   * Gets the scope resolution of this call, if any. In the following example,
+   * the result is the `ScopeResolution` for `Foo::bar`, while
+   * `getMethodName()` returns `"bar"`.
+   * ```rb
+   * Foo::bar()
+   * ```
+   */
+  final ScopeResolution getMethodScopeResolution() { result = range.getMethodScopeResolution() }
+
+  /**
+   * Gets the `n`th argument of this method call. In the following example, the
+   * result for n=0 is the `IntegerLiteral` 0, while for n=1 the result is a
+   * `Pair` (whose `getKey` returns the `SymbolLiteral` for `bar`, and
+   * `getValue` returns the `IntegerLiteral` 1). Keyword arguments like this
+   * can be accessed more naturally using the
+   * `getKeywordArgument(string keyword)` predicate.
+   * ```rb
+   * foo(0, bar: 1)
+   * ```
+   */
+  final Expr getArgument(int n) { result = range.getArgument(n) }
+
+  /**
+   * Gets an argument of this method call.
+   */
+  final Expr getAnArgument() { result = this.getArgument(_) }
+
+  /**
+   * Gets the value of the keyword argument whose key is `keyword`, if any. For
+   * example, the result for `getKeywordArgument("qux")` in the following
+   * example is the `IntegerLiteral` 123.
+   * ```rb
+   * foo :bar "baz", qux: 123
+   * ```
+   */
+  final Expr getKeywordArgument(string keyword) {
+    exists(Pair p |
+      p = this.getAnArgument() and
+      p.getKey().(SymbolLiteral).getValueText() = keyword and
+      result = p.getValue()
+    )
+  }
+
+  /**
+   * Gets the number of arguments of this method call.
+   */
+  final int getNumberOfArguments() { result = count(this.getAnArgument()) }
+
+  /**
+   * Gets the block of this method call, if any.
+   * ```rb
+   * foo.each { |x| puts x }
+   * ```
+   */
+  final Block getBlock() { result = range.getBlock() }
+}
+
+/**
+ * A call to `yield`.
+ * ```rb
+ * yield x, y
+ * ```
+ */
+class YieldCall extends Call, @yield {
+  final override YieldCall::Range range;
+
+  final override string getAPrimaryQlClass() { result = "YieldCall" }
+}
+
+/**
+ * A block argument in a method call.
+ * ```rb
+ * foo(&block)
+ * ```
+ */
+class BlockArgument extends Expr, @block_argument {
+  final override BlockArgument::Range range;
+
+  final override string getAPrimaryQlClass() { result = "BlockArgument" }
+
+  final override string toString() { result = "&..." }
+
+  /**
+   * Gets the underlying expression representing the block. In the following
+   * example, the result is the `Expr` for `bar`:
+   * ```rb
+   * foo(&bar)
+   * ```
+   */
+  final Expr getExpr() { result = range.getExpr() }
+}
+
+/**
+ * A splat argument in a method call.
+ * ```rb
+ * foo(*args)
+ * ```
+ */
+class SplatArgument extends Expr, @splat_argument {
+  final override SplatArgument::Range range;
+
+  final override string getAPrimaryQlClass() { result = "SplatArgument" }
+
+  final override string toString() { result = "*..." }
+
+  /**
+   * Gets the underlying expression. In the following example, the result is
+   * the `Expr` for `bar`:
+   * ```rb
+   * foo(*bar)
+   * ```
+   */
+  final Expr getExpr() { result = range.getExpr() }
+}
+
+/**
+ * A hash-splat (or 'double-splat') argument in a method call.
+ * ```rb
+ * foo(**options)
+ * ```
+ */
+class HashSplatArgument extends Expr, @hash_splat_argument {
+  final override HashSplatArgument::Range range;
+
+  final override string getAPrimaryQlClass() { result = "HashSplatArgument" }
+
+  final override string toString() { result = "**..." }
+
+  /**
+   * Gets the underlying expression. In the following example, the result is
+   * the `Expr` for `bar`:
+   * ```rb
+   * foo(**bar)
+   * ```
+   */
+  final Expr getExpr() { result = range.getExpr() }
+}

ql/src/codeql_ruby/ast/Call.qll

@@ -20,9 +20,9 @@ class Expr extends AstNode {
 class Literal extends Expr {
   override Literal::Range range;
 
-  override string toString() { result = this.getValueText() }
+  override string toString() { result = range.toString() }
 
-  /** Gets the source text for this literal. */
+  /** Gets the source text for this literal, if it is constant. */
   final string getValueText() { result = range.getValueText() }
 }
 
@@ -74,6 +74,35 @@ class RegexLiteral extends Literal, @regex {
   final override string getAPrimaryQlClass() { result = "RegexLiteral" }
 }
 
+/**
+ * A string literal.
+ * ```rb
+ * 'hello'
+ * "hello, #{name}"
+ * ```
+ * TODO: expand this minimal placeholder.
+ */
+class StringLiteral extends Literal, @string__ {
+  final override StringLiteral::Range range;
+
+  final override string getAPrimaryQlClass() { result = "StringLiteral" }
+}
+
+/**
+ * A symbol literal.
+ * ```rb
+ * :foo
+ * :"foo bar"
+ * :"foo bar #{baz}"
+ * ```
+ * TODO: expand this minimal placeholder.
+ */
+class SymbolLiteral extends Literal {
+  final override SymbolLiteral::Range range;
+
+  final override string getAPrimaryQlClass() { result = "SymbolLiteral" }
+}
+
 /** A sequence of expressions. */
 class ExprSequence extends Expr {
   override ExprSequence::Range range;
@@ -97,3 +126,78 @@ class ExprSequence extends Expr {
   /** Holds if this sequence has no expressions. */
   final predicate isEmpty() { this.getNumberOfExpressions() = 0 }
 }
+
+/**
+ * A scope resolution, typically used to access constants defined in a class or
+ * module.
+ * ```rb
+ * Foo::Bar
+ * ```
+ */
+class ScopeResolution extends Expr, @scope_resolution {
+  final override ScopeResolution::Range range;
+
+  final override string getAPrimaryQlClass() { result = "ScopeResolution" }
+
+  final override string toString() { result = "...::" + this.getName() }
+
+  /**
+   * Gets the expression representing the scope, if any. In the following
+   * example, the scope is the `Expr` for `Foo`:
+   * ```rb
+   * Foo::Bar
+   * ```
+   * However, in the following example, accessing the `Bar` constant in the
+   * `Object` class, there is no result:
+   * ```rb
+   * ::Bar
+   * ```
+   */
+  final Expr getScope() { result = range.getScope() }
+
+  /**
+   * Gets the name being resolved. For example, in `Foo::Bar`, the result is
+   * `"Bar"`.
+   */
+  final string getName() { result = range.getName() }
+}
+
+/**
+ * A pair expression. For example, in a hash:
+ * ```rb
+ * { foo: bar }
+ * ```
+ * Or a keyword argument:
+ * ```rb
+ * baz(qux: 1)
+ * ```
+ */
+class Pair extends Expr, @pair {
+  final override Pair::Range range;
+
+  final override string getAPrimaryQlClass() { result = "Pair" }
+
+  final override string toString() { result = "Pair" }
+
+  /**
+   * Gets the key expression of this pair. For example, the `SymbolLiteral`
+   * representing the keyword `foo` in the following example:
+   * ```rb
+   * bar(foo: 123)
+   * ```
+   * Or the `StringLiteral` for `'foo'` in the following hash pair:
+   * ```rb
+   * { 'foo' => 123 }
+   * ```
+   */
+  final Expr getKey() { result = range.getKey() }
+
+  /**
+   * Gets the value expression of this pair. For example, the `InteralLiteral`
+   * 123 in the following hash pair:
+   * ```rb
+   * { 'foo' => 123 }
+   * ```
+   */
+  final Expr getValue() { result = range.getValue() }
+}

ql/src/codeql_ruby/ast/Expr.qll

@@ -80,7 +80,7 @@ class DoBlock extends Block, @do_block {
 
   final override string getAPrimaryQlClass() { result = "DoBlock" }
 
-  final override string toString() { result = "| ... |" }
+  final override string toString() { result = "do ... end" }
 }
 
 /**