# Copyright (c) Meta Platforms, Inc. and affiliates.

schema code.24 {
import src
import code.anglelang
import code.buck
import code.csharp
import code.cxx
import code.dataswarm
import code.erlang
import code.fbthrift
import code.flow
import code.graphql
import code.hack
import code.hs
import code.java
import code.kotlin
import code.lsif
import code.pp
import code.python
import code.scip.1
import codemarkup.types

type Entity =
  {
    cxx : code.cxx.Entity |
    pp : code.pp.Entity |
    java : code.java.Entity |
    kotlin : code.kotlin.Entity |
    hs : code.hs.Entity |
    python : code.python.Entity |
    hack : code.hack.Entity |
    flow : code.flow.Entity |
    fbthrift : code.fbthrift.Entity |
    buck : code.buck.Entity |
    erlang : code.erlang.Entity |
    lsif : code.lsif.Entity |
    scip : code.scip.Entity |
    csharp : code.csharp.Entity |
    graphql : code.graphql.Entity |
    dataswarm: code.dataswarm.Entity |
    angle: code.anglelang.Entity |
  }

type SymbolId =
  {
    scip : code.scip.SymbolId |
    cxx : code.cxx.SymbolId |
  }

# language enum values for exactly the set of entity tags (including LSIF)
#
# n.b. flow => javascript, javascript is the user-facing language
#
type Language =
  enum {
    Cpp | PreProcessor | Java | Haskell | Python | Hack | JavaScript | Rust |
    Thrift | Buck | Erlang | FSharp | Go | Kotlin | OCaml | Scala | Swift |
    TypeScript | CSharp | GraphQL | Dataswarm | Yaml | Angle |
  }

# entity tag to language id
predicate EntityLanguage:
  {
    entity: Entity,
    language: Language
  }
  { Entity, Language } where
    ( { cxx = _ } = Entity; Cpp = Language ) |
    ( { pp = _ } = Entity; PreProcessor = Language ) |
    ( { java = _ } = Entity; Java = Language ) |
    ( { kotlin = _ } = Entity; Kotlin = Language ) |
    ( { hs = _ } = Entity; Haskell = Language ) |
    ( { python = _ } = Entity; Python = Language ) |
    ( { hack = _ } = Entity; Hack = Language ) |
    ( { flow = _ } = Entity; JavaScript = Language ) |
    ( { fbthrift = _ } = Entity; Thrift = Language ) |
    ( { buck = _ } = Entity; Buck = Language ) |
    ( { erlang = _ } = Entity; Erlang = Language ) |
    ( { csharp = _ } = Entity; CSharp = Language ) |
    ( { graphql = _ } = Entity; GraphQL = Language ) |
    ( { dataswarm = _ } = Entity; Dataswarm = Language ) |
    ( { angle = _ } = Entity; Angle = Language ) |
    ( { lsif = LSIF }  = Entity; EntityLanguageLSIF { LSIF, Language } ) |
    ( { scip = SCIP }  = Entity; EntityLanguageSCIP { SCIP, Language } );

# (private) helper for the LSIF subset
predicate EntityLanguageLSIF:
  {
    entity: code.lsif.Entity,
    language: Language
  }
  { LSIF, Language } where
    ( { erlang = _ } = LSIF; Erlang = Language ) |
    ( { fsharp = _ } = LSIF; FSharp = Language ) |
    ( { go = _ } = LSIF; Go = Language ) |
    ( { haskell = _ } = LSIF; Haskell = Language ) |
    ( { java = _ } = LSIF; Java = Language ) |
    ( { kotlin = _ } = LSIF; Kotlin = Language ) |
    ( { ocaml = _ } = LSIF; OCaml = Language ) |
    ( { python = _ } = LSIF; Python = Language ) |
    ( { scala = _ } = LSIF; Scala = Language ) |
    ( { swift = _ } = LSIF; Swift = Language ) |
    ( { typescript = _ } = LSIF; TypeScript = Language );

# (private) helper for the SCIP subset
predicate EntityLanguageSCIP:
  {
    entity: code.scip.Entity,
    language: Language
  }
  { SCIP, Language } where
    { rust = _ } = SCIP; Rust : Language = Language;

type Annotations =
  {
    cxx : code.cxx.Annotations |
    java : code.java.Annotations |
    python : code.python.Annotations |
    hack : code.hack.Annotations |
    fbthrift : code.fbthrift.Annotations |
  }

type Argument =
  {
    lit: string |
    xref: Entity
  }

type CallArgument =
  { label : maybe string
  , span : src.ByteSpan
  , argument : maybe Argument
  }

# An IdlEntity is used to represent xrefs to
# cross-language/cross-dbs entities. Location for these
# entities is usually defined in a different db than
# the one containing the source spans.
#
# Example: a thrift declaration defined in a Thrift db, while
# but referred to in a C++ db.
#
# "IdlEntity" is a misnomer (initially only IDL like thrift
# were supported)
#
# location and entity are optional in case we're unable to
# generate them from the referring db but still want to
# produce some type of navigation info (jump to target file)
#
type IdlEntity =
  { lang : Language
  , file : src.File
  , entity : maybe code.Entity
  , range : maybe src.Range
  }
}