overlay[local]
module;

import codeql.Locations
import ast.Call
import ast.Control
import ast.Constant
import ast.Erb
import ast.Expr
import ast.Literal
import ast.Method
import ast.Module
import ast.Parameter
import ast.Operation
import ast.Pattern
import ast.Scope
import ast.Statement
import ast.Variable
private import ast.internal.AST
private import ast.internal.Scope
private import ast.internal.Synthesis
private import ast.internal.TreeSitter
private import Customizations
private import Diagnostics

cached
private module Cached {
  cached
  ModuleBase getEnclosingModule(Scope s) {
    result = s
    or
    not s instanceof ModuleBase and result = getEnclosingModule(s.getOuterScope())
  }

  cached
  MethodBase getEnclosingMethod(Scope s) {
    result = s
    or
    not s instanceof MethodBase and
    not s instanceof ModuleBase and
    result = getEnclosingMethod(s.getOuterScope())
  }

  cached
  Toplevel getEnclosingToplevel(Scope s) {
    result = s
    or
    result = getEnclosingToplevel(s.getOuterScope())
  }
}

private import Cached

/**
 * A node in the abstract syntax tree. This class is the base class for all Ruby
 * program elements.
 */
class AstNode extends TAstNode {
  /**
   * Gets the name of a primary CodeQL class to which this node belongs.
   *
   * This predicate always has a result. If no primary class can be
   * determined, the result is `"???"`. If multiple primary classes match,
   * this predicate can have multiple results.
   */
  string getAPrimaryQlClass() { result = "???" }

  /**
   * Gets a comma-separated list of the names of the primary CodeQL classes to
   * which this element belongs.
   */
  final string getPrimaryQlClasses() { result = concat(this.getAPrimaryQlClass(), ",") }

  /** Gets the enclosing module, if any. */
  final ModuleBase getEnclosingModule() { result = getEnclosingModule(scopeOfInclSynth(this)) }

  /** Gets the enclosing method, if any. */
  final MethodBase getEnclosingMethod() { result = getEnclosingMethod(scopeOfInclSynth(this)) }

  /** Gets the enclosing top-level. */
  final Toplevel getEnclosingToplevel() { result = getEnclosingToplevel(scopeOfInclSynth(this)) }

  /** Gets a textual representation of this node. */
  cached
  string toString() { none() }

  /** Gets the location of this node. */
  Location getLocation() { result = getLocation(this) }

  /** Gets the file of this node. */
  final File getFile() { result = this.getLocation().getFile() }

  /** Gets a child node of this `AstNode`. */
  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 }

  /**
   * Gets a child of this node, which can also be retrieved using a predicate
   * named `pred`.
   */
  cached
  AstNode getAChild(string pred) {
    pred = "getDesugared" and
    result = this.getDesugared()
  }

  /**
   * Holds if this node was synthesized to represent an implicit AST node not
   * present in the source code.  In the following example method call, the
   * receiver is an implicit `self` reference, for which there is a synthesized
   * `Self` node.
   *
   * ```rb
   * foo(123)
   * ```
   */
  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) }
}

/** A Ruby source file */
class RubyFile extends File {
  RubyFile() {
    exists(Location loc |
      ruby_ast_node_location(_, loc) and
      this = loc.getFile()
    )
  }

  /** Gets a token in this file. */
  private Ruby::Token getAToken() { result.getLocation().getFile() = this }

  /** Holds if `line` contains a token. */
  private predicate line(int line, boolean comment) {
    exists(Ruby::Token token, Location l |
      token = this.getAToken() and
      l = token.getLocation() and
      line in [l.getStartLine() .. l.getEndLine()] and
      if token instanceof @ruby_token_comment then comment = true else comment = false
    )
  }

  /** Gets the number of lines in this file. */
  int getNumberOfLines() { result = max([0, this.getAToken().getLocation().getEndLine()]) }

  /** Gets the number of lines of code in this file. */
  int getNumberOfLinesOfCode() { result = count(int line | this.line(line, false)) }

  /** Gets the number of lines of comments in this file. */
  int getNumberOfLinesOfComments() { result = count(int line | this.line(line, true)) }
}

/**
 * A successfully extracted file, that is, a file that was extracted and
 * contains no extraction errors or warnings.
 */
class SuccessfullyExtractedFile extends File {
  SuccessfullyExtractedFile() {
    not exists(Diagnostic d |
      d.getLocation().getFile() = this and
      (
        d instanceof ExtractionError
        or
        d instanceof ExtractionWarning
      )
    )
  }
}