Merge pull request #7154 from aibaars/ruby-pattern-matching

Ruby: pattern matching

Author: aibaars

.github/workflows/ruby-dataset-measure.yml

@@ -24,7 +24,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        repo: [rails/rails, discourse/discourse, spree/spree]
+        repo: [rails/rails, discourse/discourse, spree/spree, ruby/ruby]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2

ruby/Cargo.lock

@@ -11,7 +11,7 @@ flate2 = "1.0"
 node-types = { path = "../node-types" }
 tree-sitter = "0.19"
 tree-sitter-embedded-template = "0.19"
-tree-sitter-ruby = { git = "https://github.com/tree-sitter/tree-sitter-ruby.git", rev = "bb6a42e42b048627a74a127d3e0184c1eef01de9" }
+tree-sitter-ruby = { git = "https://github.com/tree-sitter/tree-sitter-ruby.git", rev = "951799c6780deaabb0666b846cb7ad4eab627bbb" }
 clap = "2.33"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", features = ["env-filter"] }

ruby/extractor/Cargo.toml

@@ -12,4 +12,4 @@ node-types = { path = "../node-types" }
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", features = ["env-filter"] }
 tree-sitter-embedded-template = "0.19"
-tree-sitter-ruby = { git = "https://github.com/tree-sitter/tree-sitter-ruby.git", rev = "bb6a42e42b048627a74a127d3e0184c1eef01de9" }
+tree-sitter-ruby = { git = "https://github.com/tree-sitter/tree-sitter-ruby.git", rev = "951799c6780deaabb0666b846cb7ad4eab627bbb" }

ruby/generator/Cargo.toml

@@ -1,5 +1,6 @@
 private import codeql.ruby.AST
 private import internal.AST
+private import internal.Control
 private import internal.TreeSitter
 
 /**
@@ -308,13 +309,36 @@ class TernaryIfExpr extends ConditionalExpr, TTernaryIfExpr {
   }
 }
 
-class CaseExpr extends ControlExpr, TCaseExpr {
-  private Ruby::Case g;
-
-  CaseExpr() { this = TCaseExpr(g) }
-
-  final override string getAPrimaryQlClass() { result = "CaseExpr" }
-
+/**
+ * A `case` statement. There are three forms of `case` statements:
+ * ```rb
+ * # a value-less case expression acting like an if-elsif expression:
+ * case
+ *   when x == 0 then puts "zero"
+ *   when x > 0 then puts "positive"
+ *   else puts "negative"
+ * end
+ *
+ * # a case expression that matches a value using `when` clauses:
+ * case value
+ *   when 1, 2 then puts "a is one or two"
+ *   when 3    then puts "a is three"
+ *   else           puts "I don't know what a is"
+ * end
+ *
+ * # a case expression that matches a value against patterns using `in` clauses:
+ * config = {db: {user: 'admin', password: 'abc123'}}
+ * case config
+ *   in db: {user:} # matches subhash and puts matched value in variable user
+ *     puts "Connect with user '#{user}'"
+ *   in connection: {username: } unless username == 'admin'
+ *     puts "Connect with user '#{username}'"
+ *   else
+ *     puts "Unrecognized structure of config"
+ * end
+ * ```
+ */
+class CaseExpr extends ControlExpr instanceof CaseExprImpl {
   /**
    * Gets the expression being compared, if any. For example, `foo` in the following example.
    * ```rb
@@ -334,22 +358,25 @@ class CaseExpr extends ControlExpr, TCaseExpr {
    * end
    * ```
    */
-  final Expr getValue() { toGenerated(result) = g.getValue() }
+  final Expr getValue() { result = super.getValue() }
 
   /**
-   * Gets the `n`th branch of this case expression, either a `WhenExpr` or a
-   * `StmtSequence`.
+   * Gets the `n`th branch of this case expression, either a `WhenExpr`, an
+   * `InClause`, or a `StmtSequence`.
    */
-  final Expr getBranch(int n) { toGenerated(result) = g.getChild(n) }
+  final Expr getBranch(int n) { result = super.getBranch(n) }
 
   /**
-   * Gets a branch of this case expression, either a `WhenExpr` or an
-   * `ElseExpr`.
+   * Gets a branch of this case expression, either a `WhenExpr`, an
+   * `InClause`, or a `StmtSequence`.
    */
   final Expr getABranch() { result = this.getBranch(_) }
 
+  /** Gets the `n`th `when` branch of this case expression. */
+  deprecated final WhenExpr getWhenBranch(int n) { result = this.getBranch(n) }
+
   /** Gets a `when` branch of this case expression. */
-  final WhenExpr getAWhenBranch() { result = this.getABranch() }
+  deprecated final WhenExpr getAWhenBranch() { result = this.getABranch() }
 
   /** Gets the `else` branch of this case expression, if any. */
   final StmtSequence getElseBranch() { result = this.getABranch() }
@@ -359,14 +386,18 @@ class CaseExpr extends ControlExpr, TCaseExpr {
    */
   final int getNumberOfBranches() { result = count(this.getBranch(_)) }
 
+  final override string getAPrimaryQlClass() { result = "CaseExpr" }
+
   final override string toString() { result = "case ..." }
 
   override AstNode getAChild(string pred) {
-    result = super.getAChild(pred)
+    result = ControlExpr.super.getAChild(pred)
     or
     pred = "getValue" and result = this.getValue()
     or
     pred = "getBranch" and result = this.getBranch(_)
+    or
+    pred = "getElseBranch" and result = this.getElseBranch()
   }
 }
 
@@ -422,6 +453,81 @@ class WhenExpr extends Expr, TWhenExpr {
   }
 }
 
+/**
+ * An `in` clause of a `case` expression.
+ * ```rb
+ * case foo
+ * in [ a ] then a
+ * end
+ * ```
+ */
+class InClause extends Expr, TInClause {
+  private Ruby::InClause g;
+
+  InClause() { this = TInClause(g) }
+
+  final override string getAPrimaryQlClass() { result = "InClause" }
+
+  /** Gets the body of this case-in expression. */
+  final Stmt getBody() { toGenerated(result) = g.getBody() }
+
+  /**
+   * Gets the pattern in this case-in expression. In the
+   * following example, the pattern is `Point{ x:, y: }`.
+   * ```rb
+   * case foo
+   * in Point{ x:, y: }
+   *   x + y
+   * end
+   * ```
+   */
+  final CasePattern getPattern() { toGenerated(result) = g.getPattern() }
+
+  /**
+   * Gets the pattern guard condition in this case-in expression. In the
+   * following example, there are two pattern guard conditions `x > 10` and `x < 0`.
+   * ```rb
+   * case foo
+   * in [ x ] if x > 10 then ...
+   * in [ x ] unless x < 0 then ...
+   * end
+   * ```
+   */
+  final Expr getCondition() { toGenerated(result) = g.getGuard().getAFieldOrChild() }
+
+  /**
+   * Holds if the pattern guard in this case-in expression is an `if` condition. For example:
+   * ```rb
+   * case foo
+   * in [ x ] if x > 10 then ...
+   * end
+   * ```
+   */
+  predicate hasIfCondition() { g.getGuard() instanceof Ruby::IfGuard }
+
+  /**
+   * Holds if the pattern guard in this case-in expression is an `unless` condition. For example:
+   * ```rb
+   * case foo
+   * in [ x ] unless x < 10 then ...
+   * end
+   * ```
+   */
+  predicate hasUnlessCondition() { g.getGuard() instanceof Ruby::UnlessGuard }
+
+  final override string toString() { result = "in ... then ..." }
+
+  override AstNode getAChild(string pred) {
+    result = super.getAChild(pred)
+    or
+    pred = "getBody" and result = this.getBody()
+    or
+    pred = "getPattern" and result = this.getPattern()
+    or
+    pred = "getCondition" and result = this.getCondition()
+  }
+}
+
 /**
  * A loop. That is, a `for` loop, a `while` or `until` loop, or their
  * expression-modifier variants.

ruby/ql/lib/codeql/ruby/ast/Control.qll

@@ -223,6 +223,40 @@ private class FalseLiteral extends BooleanLiteral, TFalseLiteral {
   final override predicate isFalse() { any() }
 }
 
+/**
+ * An `__ENCODING__` literal.
+ */
+class EncodingLiteral extends Literal, TEncoding {
+  final override string getAPrimaryQlClass() { result = "EncodingLiteral" }
+
+  final override string toString() { result = "__ENCODING__" }
+
+  // TODO: return the encoding defined by a magic encoding: comment, if any.
+  override string getValueText() { result = "UTF-8" }
+}
+
+/**
+ * A `__LINE__` literal.
+ */
+class LineLiteral extends Literal, TLine {
+  final override string getAPrimaryQlClass() { result = "LineLiteral" }
+
+  final override string toString() { result = "__LINE__" }
+
+  override string getValueText() { result = this.getLocation().getStartLine().toString() }
+}
+
+/**
+ * A `__FILE__` literal.
+ */
+class FileLiteral extends Literal, TFile {
+  final override string getAPrimaryQlClass() { result = "FileLiteral" }
+
+  final override string toString() { result = "__FILE__" }
+
+  override string getValueText() { result = this.getLocation().getFile().getAbsolutePath() }
+}
+
 /**
  * The base class for a component of a string: `StringTextComponent`,
  * `StringEscapeSequenceComponent`, or `StringInterpolationComponent`.

ruby/ql/lib/codeql/ruby/ast/Literal.qll

@@ -131,6 +131,23 @@ class HashSplatParameter extends NamedParameter, THashSplatParameter {
   final override string getName() { result = g.getName().getValue() }
 }
 
+/**
+ * A `nil` hash splat (`**nil`) indicating that there are no keyword parameters or keyword patterns.
+ * For example:
+ * ```rb
+ * def foo(bar, **nil)
+ *   case bar
+ *   in { x:, **nil } then puts x
+ *   end
+ * end
+ * ```
+ */
+class HashSplatNilParameter extends Parameter, THashSplatNilParameter {
+  final override string getAPrimaryQlClass() { result = "HashSplatNilParameter" }
+
+  final override string toString() { result = "**nil" }
+}
+
 /**
  * A keyword parameter, including a default value if the parameter is optional.
  * For example, in the following example, `foo` is a keyword parameter with a