Merge pull request #179 from github/hvitved/synth-framework-take2

AST synthesis framework (take 2)

Author: hvitved

ql/consistency-queries/AstConsistency.ql

@@ -15,6 +15,14 @@ query predicate missingParent(AstNode node, string cls) {
 
 query predicate multipleParents(AstNode node, AstNode parent, string cls) {
   parent = node.getParent() and
-  count(node.getParent()) > 1 and
-  cls = getAPrimaryQlClass(parent)
+  cls = getAPrimaryQlClass(parent) and
+  exists(AstNode one, AstNode two |
+    one = node.getParent() and
+    two = node.getParent() and
+    one != two
+  |
+    one.isSynthesized() and two.isSynthesized()
+    or
+    not one.isSynthesized() and not two.isSynthesized()
+  )
 }

ql/src/codeql_ruby/AST.qll

@@ -14,6 +14,7 @@ import ast.Statement
 import ast.Variable
 private import ast.internal.AST
 private import ast.internal.Scope
+private import ast.internal.Synthesis
 
 /**
  * A node in the abstract syntax tree. This class is the base class for all Ruby
@@ -56,7 +57,11 @@ class AstNode extends TAstNode {
   final AstNode getAChild() { result = this.getAChild(_) }
 
   /** Gets the parent of this `AstNode`, if this node is not a root node. */
-  final AstNode getParent() { result.getAChild() = this }
+  final AstNode getParent() {
+    result.getAChild() = this
+    or
+    result.getAChild().getDesugared() = this
+  }
 
   /**
    * Gets a child of this node, which can also be retrieved using a predicate
@@ -75,5 +80,25 @@ class AstNode extends TAstNode {
    * foo(123)
    * ```
    */
-  predicate isSynthesized() { this instanceof TImplicitSelf }
+  final predicate isSynthesized() { this = getSynthChild(_, _) }
+
+  /**
+   * Gets the desugared version of this AST node, if any.
+   *
+   * For example, the desugared version of
+   *
+   * ```rb
+   * x += y
+   * ```
+   *
+   * is
+   *
+   * ```rb
+   * x = x + y
+   * ```
+   *
+   * when `x` is a variable. Whenever an AST node can be desugared,
+   * then the desugared version is used in the control-flow graph.
+   */
+  final AstNode getDesugared() { result = getSynthChild(this, -1) }
 }

ql/src/codeql_ruby/ast/Call.qll

@@ -137,7 +137,7 @@ private class IdentifierMethodCall extends MethodCall, TIdentifierMethodCall {
 
   final override string getMethodName() { result = getMethodName(this, g.getValue()) }
 
-  final override Self getReceiver() { result = TImplicitSelf(g) }
+  final override Self getReceiver() { result = TSelfSynth(this, 0) }
 }
 
 private class ScopeResolutionMethodCall extends MethodCall, TScopeResolutionMethodCall {
@@ -162,12 +162,7 @@ private class RegularMethodCall extends MethodCall, TRegularMethodCall {
     not exists(g.getReceiver()) and
     toGenerated(result) = g.getMethod().(Generated::ScopeResolution).getScope()
     or
-    // If there's no explicit receiver (or scope resolution that acts like a
-    // receiver), then the receiver is implicitly `self`.  N.B.  `::Foo()` is
-    // not valid Ruby.
-    not exists(g.getReceiver()) and
-    not exists(g.getMethod().(Generated::ScopeResolution).getScope()) and
-    result = TImplicitSelf(g)
+    result = TSelfSynth(this, 0)
   }
 
   final override string getMethodName() {

ql/src/codeql_ruby/ast/Expr.qll

@@ -79,6 +79,12 @@ class StmtSequence extends Expr, TStmtSequence {
   override AstNode getAChild(string pred) { pred = "getStmt" and result = this.getStmt(_) }
 }
 
+private class StmtSequenceSynth extends StmtSequence, TStmtSequenceSynth {
+  final override Stmt getStmt(int n) { synthChild(this, n, result) }
+
+  final override string toString() { result = "..." }
+}
+
 private class Then extends StmtSequence, TThen {
   private Generated::Then g;
 
@@ -210,11 +216,11 @@ class ParenthesizedExpr extends StmtSequence, TParenthesizedExpr {
 
   ParenthesizedExpr() { this = TParenthesizedExpr(g) }
 
+  final override Stmt getStmt(int n) { toGenerated(result) = g.getChild(n) }
+
   final override string getAPrimaryQlClass() { result = "ParenthesizedExpr" }
 
   final override string toString() { result = "( ... )" }
-
-  final override Stmt getStmt(int n) { toGenerated(result) = g.getChild(n) }
 }
 
 /**

ql/src/codeql_ruby/ast/Operation.qll

@@ -101,12 +101,6 @@ class DefinedExpr extends UnaryOperation, TDefinedExpr {
 
 /** A binary operation. */
 class BinaryOperation extends Operation, TBinaryOperation {
-  private Generated::Binary g;
-
-  BinaryOperation() { g = toGenerated(this) }
-
-  final override string getOperator() { result = g.getOperator() }
-
   final override Expr getAnOperand() {
     result = this.getLeftOperand() or result = this.getRightOperand()
   }
@@ -122,10 +116,28 @@ class BinaryOperation extends Operation, TBinaryOperation {
   }
 
   /** Gets the left operand of this binary operation. */
-  final Stmt getLeftOperand() { toGenerated(result) = g.getLeft() }
+  Stmt getLeftOperand() { none() }
 
   /** Gets the right operand of this binary operation. */
-  final Stmt getRightOperand() { toGenerated(result) = g.getRight() }
+  Stmt getRightOperand() { none() }
+}
+
+private class BinaryOperationReal extends BinaryOperation {
+  private Generated::Binary g;
+
+  BinaryOperationReal() { g = toGenerated(this) }
+
+  final override string getOperator() { result = g.getOperator() }
+
+  final override Stmt getLeftOperand() { toGenerated(result) = g.getLeft() }
+
+  final override Stmt getRightOperand() { toGenerated(result) = g.getRight() }
+}
+
+abstract private class BinaryOperationSynth extends BinaryOperation {
+  final override Stmt getLeftOperand() { synthChild(this, 0, result) }
+
+  final override Stmt getRightOperand() { synthChild(this, 1, result) }
 }
 
 /**
@@ -143,6 +155,10 @@ class AddExpr extends BinaryArithmeticOperation, TAddExpr {
   final override string getAPrimaryQlClass() { result = "AddExpr" }
 }
 
+private class AddExprSynth extends AddExpr, BinaryOperationSynth, TAddExprSynth {
+  final override string getOperator() { result = "+" }
+}
+
 /**
  * A subtract expression.
  * ```rb
@@ -153,6 +169,10 @@ class SubExpr extends BinaryArithmeticOperation, TSubExpr {
   final override string getAPrimaryQlClass() { result = "SubExpr" }
 }
 
+private class SubExprSynth extends SubExpr, BinaryOperationSynth, TSubExprSynth {
+  final override string getOperator() { result = "-" }
+}
+
 /**
  * A multiply expression.
  * ```rb
@@ -163,6 +183,10 @@ class MulExpr extends BinaryArithmeticOperation, TMulExpr {
   final override string getAPrimaryQlClass() { result = "MulExpr" }
 }
 
+private class MulExprSynth extends MulExpr, BinaryOperationSynth, TMulExprSynth {
+  final override string getOperator() { result = "*" }
+}
+
 /**
  * A divide expression.
  * ```rb
@@ -173,6 +197,10 @@ class DivExpr extends BinaryArithmeticOperation, TDivExpr {
   final override string getAPrimaryQlClass() { result = "DivExpr" }
 }
 
+private class DivExprSynth extends DivExpr, BinaryOperationSynth, TDivExprSynth {
+  final override string getOperator() { result = "/" }
+}
+
 /**
  * A modulo expression.
  * ```rb
@@ -183,6 +211,10 @@ class ModuloExpr extends BinaryArithmeticOperation, TModuloExpr {
   final override string getAPrimaryQlClass() { result = "ModuloExpr" }
 }
 
+private class ModuloExprSynth extends ModuloExpr, BinaryOperationSynth, TModuloExprSynth {
+  final override string getOperator() { result = "%" }
+}
+
 /**
  * An exponent expression.
  * ```rb
@@ -193,6 +225,10 @@ class ExponentExpr extends BinaryArithmeticOperation, TExponentExpr {
   final override string getAPrimaryQlClass() { result = "ExponentExpr" }
 }
 
+private class ExponentExprSynth extends ExponentExpr, BinaryOperationSynth, TExponentExprSynth {
+  final override string getOperator() { result = "**" }
+}
+
 /**
  * A binary logical operation.
  */
@@ -209,6 +245,10 @@ class LogicalAndExpr extends BinaryLogicalOperation, TLogicalAndExpr {
   final override string getAPrimaryQlClass() { result = "LogicalAndExpr" }
 }
 
+private class LogicalAndExprSynth extends LogicalAndExpr, BinaryOperationSynth, TLogicalAndExprSynth {
+  final override string getOperator() { result = "&&" }
+}
+
 /**
  * A logical OR operation, using either `or` or `||`.
  * ```rb
@@ -220,6 +260,10 @@ class LogicalOrExpr extends BinaryLogicalOperation, TLogicalOrExpr {
   final override string getAPrimaryQlClass() { result = "LogicalOrExpr" }
 }
 
+private class LogicalOrExprSynth extends LogicalOrExpr, BinaryOperationSynth, TLogicalOrExprSynth {
+  final override string getOperator() { result = "||" }
+}
+
 /**
  * A binary bitwise operation.
  */
@@ -235,6 +279,10 @@ class LShiftExpr extends BinaryBitwiseOperation, TLShiftExpr {
   final override string getAPrimaryQlClass() { result = "LShiftExpr" }
 }
 
+private class LShiftExprSynth extends LShiftExpr, BinaryOperationSynth, TLShiftExprSynth {
+  final override string getOperator() { result = "<<" }
+}
+
 /**
  * A right-shift operation.
  * ```rb
@@ -245,6 +293,10 @@ class RShiftExpr extends BinaryBitwiseOperation, TRShiftExpr {
   final override string getAPrimaryQlClass() { result = "RShiftExpr" }
 }
 
+private class RShiftExprSynth extends RShiftExpr, BinaryOperationSynth, TRShiftExprSynth {
+  final override string getOperator() { result = ">>" }
+}
+
 /**
  * A bitwise AND operation.
  * ```rb
@@ -255,6 +307,10 @@ class BitwiseAndExpr extends BinaryBitwiseOperation, TBitwiseAndExpr {
   final override string getAPrimaryQlClass() { result = "BitwiseAndExpr" }
 }
 
+private class BitwiseAndSynthExpr extends BitwiseAndExpr, BinaryOperationSynth, TBitwiseAndExprSynth {
+  final override string getOperator() { result = "&" }
+}
+
 /**
  * A bitwise OR operation.
  * ```rb
@@ -265,6 +321,10 @@ class BitwiseOrExpr extends BinaryBitwiseOperation, TBitwiseOrExpr {
   final override string getAPrimaryQlClass() { result = "BitwiseOrExpr" }
 }
 
+private class BitwiseOrSynthExpr extends BitwiseOrExpr, BinaryOperationSynth, TBitwiseOrExprSynth {
+  final override string getOperator() { result = "|" }
+}
+
 /**
  * An XOR (exclusive OR) operation.
  * ```rb
@@ -275,6 +335,10 @@ class BitwiseXorExpr extends BinaryBitwiseOperation, TBitwiseXorExpr {
   final override string getAPrimaryQlClass() { result = "BitwiseXorExpr" }
 }
 
+private class BitwiseXorSynthExpr extends BitwiseXorExpr, BinaryOperationSynth, TBitwiseXorExprSynth {
+  final override string getOperator() { result = "^" }
+}
+
 /**
  * A comparison operation. That is, either an equality operation or a
  * relational operation.
@@ -455,17 +519,25 @@ class Assignment extends Operation, TAssignment {
  * ```
  */
 class AssignExpr extends Assignment, TAssignExpr {
+  final override string getOperator() { result = "=" }
+
+  final override string getAPrimaryQlClass() { result = "AssignExpr" }
+}
+
+private class AssignExprReal extends AssignExpr, TAssignExprReal {
   private Generated::Assignment g;
 
-  AssignExpr() { this = TAssignExpr(g) }
+  AssignExprReal() { this = TAssignExprReal(g) }
 
   final override Pattern getLeftOperand() { toGenerated(result) = g.getLeft() }
 
   final override Expr getRightOperand() { toGenerated(result) = g.getRight() }
+}
 
-  final override string getOperator() { result = "=" }
+private class AssignExprSynth extends AssignExpr, TAssignExprSynth {
+  final override Pattern getLeftOperand() { synthChild(this, 0, result) }
 
-  override string getAPrimaryQlClass() { result = "AssignExpr" }
+  final override Expr getRightOperand() { synthChild(this, 1, result) }
 }
 
 /**