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

schema codemarkup.java.1 {

import src
import code.java
import codemarkup.types
import java.alpha

#
# Resolving locations to entities
#

predicate JavaResolveLocation:
  {
    location: codemarkup.types.Location,
    entity: code.java.Entity,
  }
  { { Name, File, { span = Span }, nothing }, { decl = Decl } } where
    java.alpha.FileDeclarations { File, Decl };
    java.alpha.DeclarationLocation { Decl, Name, File, Span }

#
# Finding entities' locations
#

predicate JavaEntityLocation:
  {
    entity: code.java.Entity,
    location: codemarkup.types.Location,
  }
  { Entity, { Name, File, { span = Span }, nothing } } where
    { decl = Decl } = Entity;
    java.alpha.DeclarationLocation { Decl, Name, File, Span };

#
# Finding references in a file
#

# XRefs
predicate JavalFileEntityXRefLocations:
  {
    file: src.File,
    xref: codemarkup.types.XRefLocation,
    entity: code.java.Entity,
  }
  { File, { Location, { span = SrcSpan } }, { decl = Decl } } where
    ( # "regular" xrefs in the body of code
      java.alpha.FileXRefs { File, XRefs };
      { XRef, Spans } = XRefs[..];
      SrcSpan = Spans[..];
      java.alpha.XRefTargetDeclaration { XRef, Decl };
      java.alpha.DeclarationLocation { Decl, Name, TargetFile, TargetSpan };
      if ( File = TargetFile ) # work around T158599862 self-xrefs
      then ( SrcSpan != TargetSpan )
      else ( _ = true );
      Location = codemarkup.types.Location
        { Name, TargetFile, { span = TargetSpan }, nothing };

      # xrefs in type signatures and other signature components
    ) | (
      java.alpha.FileDeclarations { File, SrcDecl };
      java.alpha.DeclarationType { SrcDecl, Type };
      java.alpha.XRefOfType { Type, Decl, SrcSpan };
      java.alpha.DeclarationLocation { Decl, Name, TargetFile, TargetSpan };
      Location = codemarkup.types.Location
        { Name, TargetFile, { span = TargetSpan }, nothing };
    )

#
# Language entity uses
#

predicate JavaEntityUses:
  {
    target: code.java.Entity,
    file: src.File,
    span: src.ByteSpan,
  }
  { { decl = Decl }, File, Span } where
    java.alpha.DeclarationUses { Decl, File, Spans };
    Span = Spans[..]

#
# Modififiers, visibility and kinds
#

predicate JavaVisibility:
  {
    entity: code.java.Entity,
    visibility: codemarkup.types.Visibility
  }
  { { decl = Decl } , Visibility } where
    ( { param = PDecl } = Decl; { modifier = Ms } = PDecl ) |
    ( { local = LDecl } = Decl; { modifier = Ms } = LDecl ) |
    ( { field = FDecl } = Decl; { modifiers = Ms } = FDecl ) |
    ( { ctor = CDecl } = Decl; { modifiers = Ms } = CDecl ) |
    ( { method = MDecl } = Decl; { modifiers = Ms } = MDecl ) |
    ( { interface_ = IDecl } = Decl; { modifiers = Ms } = IDecl ) |
    ( { class_ = CDecl } = Decl; { modifiers = Ms } = CDecl ) |
    ( { enum_ = EDecl } = Decl; { modifiers = Ms } = EDecl );
    M = Ms[..];
    ( java.alpha.Modifier private_ = M ; Private ) |
    ( java.alpha.Modifier protected_ = M ; Protected ) |
    ( java.alpha.Modifier public_ = M ; Public ) = Visibility;

predicate JavaModifiers:
  {
    entity: code.java.Entity,
    modifiers: codemarkup.types.Modifiers
  }
  { { decl = Decl }, Modifiers } where

    ( { param = PDecl } = Decl; { modifier = Ms } = PDecl ) |
    ( { local = LDecl } = Decl; { modifier = Ms } = LDecl ) |
    ( { field = FDecl } = Decl; { modifiers = Ms } = FDecl ) |
    ( { ctor = CDecl } = Decl; { modifiers = Ms } = CDecl ) |
    ( { method = MDecl } = Decl; { modifiers = Ms } = MDecl ) |
    ( { interface_ = IDecl } = Decl; { modifiers = Ms } = IDecl ) |
    ( { class_ = CDecl } = Decl; { modifiers = Ms } = CDecl ) |
    ( { enum_ = EDecl } = Decl; { modifiers = Ms } = EDecl );
    _ = Ms; # defeat binds check
    IsAbstract = if ( Ms[..] = java.alpha.Modifier abstract_ )
      then (true) else (false);
    IsFinal = if ( Ms[..] = java.alpha.Modifier final_ )
      then (true) else (false);
    IsStatic = if ( Ms[..] = java.alpha.Modifier static_ )
      then (true) else (false);
    IsVolatile =
      if ( Ms[..] = java.alpha.Modifier volatile_ )
        then (true) else (false);
    # also: default, native, strictfp, synchronized, transient
    { isAbstract = IsAbstract,
      isFinal = IsFinal,
      isAsync = false,
      isStatic = IsStatic,
      isReadonly = false,
      isConst = false,
      isMutable = false,
      isVolatile = IsVolatile,
      isVirtual = false,
      isInline = false } = Modifiers;

# kinds and symbol info
predicate JavaEntityKind:
  {
    entity: code.java.Entity,
    kind: codemarkup.types.SymbolKind
  }
  { Entity, Kind} where
    { decl = Decl } = Entity;
    ( { param = _ } = Decl; Variable = Kind ) |
    ( { field = _ } = Decl; Field = Kind ) |
    ( { local = _ } = Decl; Variable = Kind ) |
    ( { ctor = _ } = Decl; Constructor = Kind ) |
    ( { method = _ } = Decl; Method = Kind ) |
    ( { interface_ = _ } = Decl; Interface = Kind ) |
    ( { class_ = _ } = Decl; Class_ = Kind ) |
    ( { enum_ = _ } = Decl; Enum_ = Kind );

# annotations and attributes
predicate JavaAnnotation :
  {
    entity: code.java.Entity,
    anns: code.java.Annotations,
  }
  { { decl = Decl }, { annotations = Anns } } where
    java.alpha.DeclarationAnnotations { Decl, Anns };
    Anns != []; # filter out all the empty results. no match implies empty

#
# Relationships
#

predicate JavaContainsParentEntity:
  {
    child: code.java.Entity,
    parent: code.java.Entity
  }
  { { decl = Child }, { decl = Parent } } where
    java.alpha.ParentDeclaration { Child, Parent };

predicate JavaContainsChildEntity:
  {
    parent: code.java.Entity,
    child: code.java.Entity
  }
  { { decl = Parent }, { decl = Child } } where
    java.alpha.ContainsDeclaration { Parent, Child };

predicate JavaExtendsParentEntity:
  {
    child: code.java.Entity,
    parent: code.java.Entity
  }
  { { decl = Child }, { decl = Parent } } where
    java.alpha.ExtendsDeclaration { Child, Parent };

predicate JavaExtendsChildEntity:
  {
    child: code.java.Entity,
    parent: code.java.Entity
  }
  { { decl = Parent }, { decl = Child } } where
    java.alpha.ExtendedByDeclaration { Parent, Child };

predicate JavaEntityDocumentation :
  {
    entity : code.java.Entity,
    file : src.File,
    span : src.ByteSpan
  }
  { Entity, File, Span } where
    { decl = Decl } = Entity;
    java.alpha.DeclarationComment { Decl, File, Span }

}