codeql/csharp/ql/src/Telemetry/ExtractorInformation.ql

/**
 * @name C# extraction information
 * @description Information about the extraction for a C# database
 * @kind metric
 * @tags summary telemetry
 * @id cs/telemetry/extraction-information
 */

import csharp
import semmle.code.csharp.commons.Diagnostics
import DatabaseQuality

predicate compilationInfo(string key, float value) {
  not key.matches("Compiler diagnostic count for%") and
  not key.matches("Extractor message count for group%") and
  exists(Compilation c, string infoKey, string infoValue | infoValue = c.getInfo(infoKey) |
    key = infoKey and
    value = infoValue.toFloat()
    or
    not exists(infoValue.toFloat()) and
    key = infoKey + ": " + infoValue and
    value = 1
  )
}

predicate compilerDiagnostics(string key, int value) {
  key.matches("Compiler diagnostic count for%") and
  strictsum(Compilation c | | c.getInfo(key).toInt()) = value
}

predicate extractorMessages(string key, int value) {
  key.matches("Extractor message count for group%") and
  strictsum(Compilation c | | c.getInfo(key).toInt()) = value
}

predicate fileCount(string key, int value) {
  key = "Number of files" and
  value = strictcount(File f)
}

predicate fileCountByExtension(string key, int value) {
  exists(string extension |
    key = "Number of files with extension " + extension and
    value = strictcount(File f | f.getExtension() = extension)
  )
}

predicate totalNumberOfLines(string key, int value) {
  key = "Total number of lines" and
  value = strictsum(File f | any() | f.getNumberOfLines())
}

predicate numberOfLinesOfCode(string key, int value) {
  key = "Number of lines of code" and
  value = strictsum(File f | any() | f.getNumberOfLinesOfCode())
}

predicate totalNumberOfLinesByExtension(string key, int value) {
  exists(string extension |
    key = "Total number of lines with extension " + extension and
    value = strictsum(File f | f.getExtension() = extension | f.getNumberOfLines())
  )
}

predicate numberOfLinesOfCodeByExtension(string key, int value) {
  exists(string extension |
    key = "Number of lines of code with extension " + extension and
    value = strictsum(File f | f.getExtension() = extension | f.getNumberOfLinesOfCode())
  )
}

predicate extractorDiagnostics(string key, int value) {
  exists(int severity |
    key = "Number of diagnostics with severity " + severity.toString() and
    value = strictcount(Diagnostic d | d.getSeverity() = severity)
  )
}

CompilerError getAmbiguityCompilerError() {
  result.getSeverity() >= 3 and
  result.getTag() = ["CS0101", "CS0104", "CS0111", "CS0121", "CS0229"]
}

predicate numberOfAmbiguityCompilerErrors(string key, int value) {
  value = count(getAmbiguityCompilerError()) and
  key = "Number of compiler reported ambiguity errors"
}

predicate numberOfDistinctAmbiguityCompilerErrorMessages(string key, int value) {
  value = count(getAmbiguityCompilerError().getFullMessage()) and
  key = "Number of compiler reported ambiguity error messages"
}

predicate extractionIsStandalone(string key, int value) {
  (
    value = 1 and
    extractionIsStandalone()
    or
    value = 0 and
    not extractionIsStandalone()
  ) and
  key = "Is extracted with build-mode set to 'none'"
}

module TypeMentionTypeStats implements StatsSig {
  int getNumberOfOk() { result = count(TypeMention t | not t.getType() instanceof UnknownType) }

  int getNumberOfNotOk() { result = count(TypeMention t | t.getType() instanceof UnknownType) }

  string getOkText() { result = "type mentions with known type" }

  string getNotOkText() { result = "type mentions with unknown type" }
}

module AccessTargetStats implements StatsSig {
  int getNumberOfOk() { result = count(Access a | exists(a.getTarget())) }

  int getNumberOfNotOk() { result = count(Access a | not exists(a.getTarget())) }

  string getOkText() { result = "access with target" }

  string getNotOkText() { result = "access with missing target" }
}

module ExprStats implements StatsSig {
  int getNumberOfOk() { result = count(Expr e | not e instanceof @unknown_expr) }

  int getNumberOfNotOk() { result = count(Expr e | e instanceof @unknown_expr) }

  string getOkText() { result = "expressions with known kind" }

  string getNotOkText() { result = "expressions with unknown kind" }
}

module TypeMentionTypeStatsReport = ReportStats<TypeMentionTypeStats>;

module AccessTargetStatsReport = ReportStats<AccessTargetStats>;

module ExprStatsReport = ReportStats<ExprStats>;

predicate analyzerAssemblies(string key, float value) {
  exists(Compilation c, string arg |
    c.getExpandedArgument(_) = arg and
    arg.indexOf("/analyzer:") = 0 and
    key = "CSC analyzer: " + arg.substring(10, arg.length())
  ) and
  value = 1.0
}

from string key, float value
where
  (
    compilationInfo(key, value) or
    compilerDiagnostics(key, value) or
    extractorMessages(key, value) or
    fileCount(key, value) or
    fileCountByExtension(key, value) or
    totalNumberOfLines(key, value) or
    numberOfLinesOfCode(key, value) or
    totalNumberOfLinesByExtension(key, value) or
    numberOfLinesOfCodeByExtension(key, value) or
    extractorDiagnostics(key, value) or
    numberOfAmbiguityCompilerErrors(key, value) or
    numberOfDistinctAmbiguityCompilerErrorMessages(key, value) or
    extractionIsStandalone(key, value) or
    CallTargetStatsReport::numberOfOk(key, value) or
    CallTargetStatsReport::numberOfNotOk(key, value) or
    CallTargetStatsReport::percentageOfOk(key, value) or
    ExprTypeStatsReport::numberOfOk(key, value) or
    ExprTypeStatsReport::numberOfNotOk(key, value) or
    ExprTypeStatsReport::percentageOfOk(key, value) or
    TypeMentionTypeStatsReport::numberOfOk(key, value) or
    TypeMentionTypeStatsReport::numberOfNotOk(key, value) or
    TypeMentionTypeStatsReport::percentageOfOk(key, value) or
    AccessTargetStatsReport::numberOfOk(key, value) or
    AccessTargetStatsReport::numberOfNotOk(key, value) or
    AccessTargetStatsReport::percentageOfOk(key, value) or
    ExprStatsReport::numberOfOk(key, value) or
    ExprStatsReport::numberOfNotOk(key, value) or
    ExprStatsReport::percentageOfOk(key, value) or
    analyzerAssemblies(key, value)
  ) and
  /* Infinity */
  value != 1.0 / 0.0 and
  /* -Infinity */
  value != -1.0 / 0.0 and
  /* NaN */
  value != 0.0 / 0.0
select key, value