/**

* Provides classes and predicates for working with members of Java classes and interfaces,

* that is, methods, constructors, fields and nested types.

*/

overlay[local?]

module;

import Element

import Type

import Annotation

import Exception

import metrics.MetricField

private import dispatch.VirtualDispatch

private import semmle.code.java.Overlay

/**

* A common abstraction for type member declarations,

* including methods, constructors, fields, and nested types.

*/

class Member extends Element, Annotatable, Modifiable, @member {

Member() { declaresMember(_, this) }

/** Gets the type in which this member is declared. */

RefType getDeclaringType() { declaresMember(result, this) }

/**

* Gets the qualified name of this member.

* This is useful for debugging, but for normal use `hasQualifiedName`

* is recommended, as it is more efficient.

*/

string getQualifiedName() {

result = this.getDeclaringType().getQualifiedName() + "." + this.getName()

}

/**

* Holds if this member has the specified name and is declared in the

* specified package and type.

*/

pragma[nomagic]

predicate hasQualifiedName(string package, string type, string name) {

this.getDeclaringType().hasQualifiedName(package, type) and this.hasName(name)

}

/** Holds if this member is package protected, that is, neither public nor private nor protected. */

predicate isPackageProtected() {

not this.isPrivate() and

not this.isProtected() and

not this.isPublic()

}

/**

* Gets the immediately enclosing callable, if this member is declared in

* an anonymous or local class or interface.

*/

Callable getEnclosingCallable() {

exists(NestedType nt | this.getDeclaringType() = nt |

nt.(AnonymousClass).getClassInstanceExpr().getEnclosingCallable() = result or

nt.(LocalClassOrInterface).getLocalTypeDeclStmt().getEnclosingCallable() = result

)

}

}

/** A callable is a method or constructor. */

class Callable extends StmtParent, Member, @callable {

/**

* Gets the declared return type of this callable (`void` for

* constructors).

*/

Type getReturnType() {

constrs(this, _, _, result, _, _) or

methods(this, _, _, result, _, _)

}

/**

* Gets the declared return Kotlin type of this callable (`Nothing` for

* constructors).

*/

KotlinType getReturnKotlinType() {

constrsKotlinType(this, result) or

methodsKotlinType(this, result)

}

/**

* Gets a callee that may be called from this callable.

*/

Callable getACallee() { this.calls(result) }

/** Gets the call site of a call from this callable to a callee. */

Call getACallSite(Callable callee) {

result.getCaller() = this and

result.getCallee() = callee

}

/**

* Gets the bytecode method descriptor, encoding parameter and return types,

* but not the name of the callable.

*/

string getMethodDescriptor() {

exists(string return | return = this.getReturnType().getTypeDescriptor() |

result = "(" + this.descriptorUpTo(this.getNumberOfParameters()) + ")" + return

)

}

private string descriptorUpTo(int n) {

n = 0 and result = ""

or

exists(Parameter p | p = this.getParameter(n - 1) |

result = this.descriptorUpTo(n - 1) + p.getType().getTypeDescriptor()

)

}

/** Holds if this callable calls `target`. */

predicate calls(Callable target) { exists(this.getACallSite(target)) }

/**

* Holds if this callable calls `target`

* using a `super(...)` constructor call.

*/

predicate callsSuperConstructor(Constructor target) {

this.getACallSite(target) instanceof SuperConstructorInvocationStmt

}

/**

* Holds if this callable calls `target`

* using a `this(...)` constructor call.

*/

predicate callsThis(Constructor target) {

this.getACallSite(target) instanceof ThisConstructorInvocationStmt

}

/**

* Holds if this callable calls `target`

* using a `super` method call.

*/

predicate callsSuper(Method target) { this.getACallSite(target) instanceof SuperMethodCall }

/**

* Holds if this callable calls `c` using

* either a `super(...)` constructor call

* or a `this(...)` constructor call.

*/

predicate callsConstructor(Constructor c) { this.callsSuperConstructor(c) or this.callsThis(c) }

/**

* Holds if this callable may call the specified callable,

* taking virtual dispatch into account.

*

* This includes both static call targets and dynamic dispatch targets.

*/

predicate polyCalls(Callable m) { this.calls(m) or this.callsImpl(m) }

/**

* Holds if `c` is a viable implementation of a callable called by this

* callable, taking virtual dispatch resolution into account.

*/

predicate callsImpl(Callable c) {

exists(Call call |

call.getCaller() = this and

viableCallable(call) = c

)

}

/**

* Holds if field `f` may be assigned a value

* within the body of this callable.

*/

predicate writes(Field f) { f.getAnAccess().(VarWrite).getEnclosingCallable() = this }

/**

* Holds if field `f` may be read

* within the body of this callable.

*/

predicate reads(Field f) { f.getAnAccess().(VarRead).getEnclosingCallable() = this }

/**

* Holds if field `f` may be either read or written

* within the body of this callable.

*/

predicate accesses(Field f) { this.writes(f) or this.reads(f) }

/**

* Gets a field accessed in this callable.

*/

Field getAnAccessedField() { this.accesses(result) }

/** Gets the type of a formal parameter of this callable. */

Type getAParamType() { result = this.getParameterType(_) }

/** Holds if this callable does not have any formal parameters. */

predicate hasNoParameters() { not exists(this.getAParameter()) }

/** Gets the number of formal parameters of this callable. */

int getNumberOfParameters() { result = count(this.getAParameter()) }

/** Gets a formal parameter of this callable. */

Parameter getAParameter() { result.getCallable() = this }

/** Gets the formal parameter at the specified (zero-based) position. */

Parameter getParameter(int n) { params(result, _, n, this, _) }

/** Gets the type of the formal parameter at the specified (zero-based) position. */

Type getParameterType(int n) { params(_, result, n, this, _) }

/** Gets the type of the formal parameter at the specified (zero-based) position. */

KotlinType getParameterKotlinType(int n) { paramsKotlinType(this.getParameter(n), result) }

/**

* Gets the signature of this callable, including its name and the types of all

* its parameters, identified by their simple (unqualified) names.

*

* The format of the string is `<name><params>`, where `<name>` is the result of

* the predicate `getName()` and `<params>` is the result of `paramsString()`.

* For example, the method `void printf(java.lang.String, java.lang.Object...)`

* has the string signature `printf(String, Object[])`.

*

* Use `getSignature` to obtain a signature including fully qualified type names.

*/

string getStringSignature() { result = this.getName() + this.paramsString() }

/**

* Gets a parenthesized string containing all parameter types of this callable,

* separated by a comma and space. For the parameter types the unqualified string

* representation is used. If this callable has no parameters, the result is `()`.

*

* For example, the method `void printf(java.lang.String, java.lang.Object...)`

* has the params string `(String, Object[])`.

*/

pragma[nomagic]

string paramsString() {

exists(int n | n = this.getNumberOfParameters() |

n = 0 and result = "()"

or

n > 0 and result = "(" + this.paramUpTo(n - 1) + ")"

)

}

/**

* Gets a string containing the parameter types of this callable

* from left to right, up to (and including) the `n`-th parameter.

*/

private string paramUpTo(int n) {

n = 0 and result = this.getParameterType(0).toString()

or

n > 0 and result = this.paramUpTo(n - 1) + ", " + this.getParameterType(n)

}

/**

* Holds if this callable has the specified string signature.

*

* This predicate simply tests if `sig` is equal to the result of the

* `getStringSignature()` predicate.

*/

predicate hasStringSignature(string sig) { sig = this.getStringSignature() }

/** Gets an exception that occurs in the `throws` clause of this callable. */

Exception getAnException() { exceptions(result, _, this) }

/** Gets an exception type that occurs in the `throws` clause of this callable. */

RefType getAThrownExceptionType() {

result = this.getAnException().getType()

or

exists(Annotation a |

this.getAnAnnotation() = a and

a.getType().hasQualifiedName("kotlin.jvm", "Throws") and

a.getATypeArrayValue(_) = result

)

}

/** Gets a call site that references this callable. */

Call getAReference() { result.getCallee() = this }

/** Gets the body of this callable, if any. */

BlockStmt getBody() { result.getParent() = this }

/**

* Gets the source declaration of this callable.

*

* For parameterized instances of generic methods, the

* source declaration is the corresponding generic method.

*

* For non-parameterized callables declared inside a parameterized

* instance of a generic type, the source declaration is the

* corresponding callable in the generic type.

*

* For all other callables, the source declaration is the callable itself.

*/

Callable getSourceDeclaration() { result = this }

/** Holds if this callable is the same as its source declaration. */

predicate isSourceDeclaration() { this.getSourceDeclaration() = this }

/** Cast this callable to a class that provides access to metrics information. */

MetricCallable getMetrics() { result = this }

/** Holds if the last parameter of this callable is a varargs (variable arity) parameter. */

predicate isVarargs() { this.getAParameter().isVarargs() }

/** Gets the index of this callable's varargs parameter, if any exists. */

int getVaragsParameterIndex() { this.getParameter(result).isVarargs() }

/**

* Gets the signature of this callable, where all types in the signature have a fully-qualified name.

* The parameter types are only separated by a comma (without space). If this callable has

* no parameters, the callable name is followed by `()`.

*

* For example, method `void m(String s, int i)` has the signature `m(java.lang.String,int)`.

*/

string getSignature() {

constrs(this, _, result, _, _, _) or

methods(this, _, result, _, _, _)

}

/**

* Gets this callable's Kotlin proxy that supplies default parameter values, if one exists.

*

* For example, for the Kotlin declaration `fun f(x: Int, y: Int = 0, z: String = "1")`,

* this will get the synthetic proxy method that fills in the default values for `y` and `z`

* if not supplied, and to which the Kotlin extractor dispatches calls to `f` that are missing

* one or more parameter value. Similarly, constructors with one or more default parameter values

* have a corresponding constructor that fills in default values.

*/

Callable getKotlinParameterDefaultsProxy() {

this.getDeclaringType() = result.getDeclaringType() and

exists(

int proxyNParams, int extraLeadingParams, int regularParamsStartIdx, RefType lastParamType

|

proxyNParams = result.getNumberOfParameters() and

extraLeadingParams = (proxyNParams - this.getNumberOfParameters()) - 2 and

extraLeadingParams >= 0 and

result.getParameterType(proxyNParams - 1) = lastParamType and

result.getParameterType(proxyNParams - 2).(PrimitiveType).hasName("int") and

(

this instanceof Constructor and

result instanceof Constructor and

extraLeadingParams = 0 and

regularParamsStartIdx = 0 and

lastParamType.hasQualifiedName("kotlin.jvm.internal", "DefaultConstructorMarker")

or

this instanceof Method and

result instanceof Method and

this.getName() + "$default" = result.getName() and

extraLeadingParams <= 1 and // 0 for static methods, 1 for instance methods

regularParamsStartIdx = extraLeadingParams and

lastParamType instanceof TypeObject

)

|

forall(int paramIdx | paramIdx in [regularParamsStartIdx .. proxyNParams - 3] |

this.getParameterType(paramIdx - extraLeadingParams).getErasure() =

eraseRaw(result.getParameterType(paramIdx))

)

)

}

}

/**

* Holds if the given type is public and, if it is a nested type, that all of

* its enclosing types are public as well.

*/

private predicate veryPublic(RefType t) {

t.isPublic() and

(

not t instanceof NestedType or

veryPublic(t.(NestedType).getEnclosingType())

)

}

/** A callable that is the same as its source declaration. */

class SrcCallable extends Callable {

SrcCallable() { this.isSourceDeclaration() }

/**

* Holds if this callable is effectively public in the sense that it can be

* called from outside the codebase. This means either a `public` callable on

* a sufficiently public type or a `protected` callable on a sufficiently

* public non-`final` type.

*/

predicate isEffectivelyPublic() {

exists(RefType t | t = this.getDeclaringType() |

this.isPublic() and veryPublic(t)

or

this.isProtected() and not t.isFinal() and veryPublic(t)

)

or

exists(SrcRefType tsub, Method m |

veryPublic(tsub) and

tsub.hasMethod(m, _) and

m.getSourceDeclaration() = this

|

this.isPublic()

or

this.isProtected() and not tsub.isFinal()

)

}

/**

* Holds if this callable is implicitly public in the sense that it can be the

* target of virtual dispatch by a call from outside the codebase.

*/

predicate isImplicitlyPublic() {

this.isEffectivelyPublic()

or

exists(SrcMethod m |

m.(SrcCallable).isEffectivelyPublic() and

m.getAPossibleImplementationOfSrcMethod() = this

)

}

}

/** Gets the erasure of `t1` if it is a raw type, or `t1` itself otherwise. */

private Type eraseRaw(Type t1) {

if t1 instanceof RawType then result = t1.getErasure() else result = t1

}

/** Holds if method `m1` overrides method `m2`. */

private predicate overrides(Method m1, Method m2) {

exists(RefType t1, RefType t2 | overridesIgnoringAccess(m1, t1, m2, t2) |

m2.isPublic()

or

m2.isProtected()

or

m2.isPackageProtected() and

pragma[only_bind_out](t1.getPackage()) = pragma[only_bind_out](t2.getPackage())

)

}

pragma[nomagic]

private predicate overridesCandidateType(RefType tsup, string sig, RefType t, Method m) {

virtualMethodWithSignature(sig, t, m) and

t.extendsOrImplements(tsup)

or

exists(RefType mid |

overridesCandidateType(mid, sig, t, m) and

mid.extendsOrImplements(tsup) and

not virtualMethodWithSignature(sig, mid, _)

)

}

/**

* Auxiliary predicate: whether method `m1` overrides method `m2`,

* ignoring any access modifiers. Additionally, this predicate binds

* `t1` to the type declaring `m1` and `t2` to the type declaring `m2`.

*/

cached

predicate overridesIgnoringAccess(Method m1, RefType t1, Method m2, RefType t2) {

exists(string sig |

overridesCandidateType(t2, sig, t1, m1) and

virtualMethodWithSignature(sig, t2, m2)

)

}

private predicate virtualMethodWithSignature(string sig, RefType t, Method m) {

methods(m, _, _, _, t, _) and

sig = m.getSignature() and

m.isVirtual()

}

private predicate potentialInterfaceImplementationWithSignature(string sig, RefType t, Method impl) {

t.hasMethod(impl, _) and

sig = impl.getSignature() and

impl.isVirtual() and

impl.isPublic() and

not t instanceof Interface and

not t.isAbstract()

}

pragma[noinline]

private predicate isInterfaceSourceImplementation(Method minst, RefType t) {

exists(Interface i |

i = minst.getDeclaringType() and

t.extendsOrImplements+(i) and

t.isSourceDeclaration()

)

}

pragma[nomagic]

private predicate implementsInterfaceMethod(SrcMethod impl, SrcMethod m) {

exists(RefType t, Method minst, Method implinst |

isInterfaceSourceImplementation(minst, t) and

potentialInterfaceImplementationWithSignature(minst.getSignature(), t, implinst) and

m = minst.getSourceDeclaration() and

impl = implinst.getSourceDeclaration()

)

}

/** A method is a particular kind of callable. */

class Method extends Callable, @method {

/** Holds if this method (directly) overrides the specified callable. */

predicate overrides(Method m) { overrides(this, m) }

/**

* Holds if this method either overrides `m`, or `m` is the

* source declaration of this method (and not equal to it).

*/

predicate overridesOrInstantiates(Method m) {

this.overrides(m)

or

this.getSourceDeclaration() = m and this != m

}

/** Gets a method (directly or transitively) overridden by this method. */

Method getAnOverride() { this.overrides+(result) }

/** Gets the source declaration of a method overridden by this method. */

SrcMethod getASourceOverriddenMethod() {

exists(Method m | this.overrides(m) and result = m.getSourceDeclaration())

}

override string getSignature() { methods(this, _, result, _, _, _) }

/**

* Holds if this method and method `m` are declared in the same type

* and have the same parameter types.

*/

predicate sameParamTypes(Method m) {

// `this` and `m` are different methods,

this != m and

// `this` and `m` are declared in the same type,

this.getDeclaringType() = m.getDeclaringType() and

// `this` and `m` are of the same arity, and

this.getNumberOfParameters() = m.getNumberOfParameters() and

// there does not exist a pair of parameters whose types differ.

not exists(int n | this.getParameterType(n) != m.getParameterType(n))

}

override SrcMethod getSourceDeclaration() { methods(this, _, _, _, _, result) }

/**

* All the methods that could possibly be called when this method

* is called. For class methods this includes the method itself and all its

* overriding methods (if any), and for interface methods this includes

* matching methods defined on or inherited by implementing classes.

*

* Only includes method implementations, not abstract or non-default interface methods.

* Native methods are included, since they have an implementation (just not in Java).

*/

SrcMethod getAPossibleImplementation() {

this.getSourceDeclaration().getAPossibleImplementationOfSrcMethod() = result

}

override MethodCall getAReference() { result = Callable.super.getAReference() }

override predicate isPublic() {

Callable.super.isPublic()

or

// JLS 9.4: Every method declaration in the body of an interface without an

// access modifier is implicitly public.

this.getDeclaringType() instanceof Interface and

not this.isPrivate()

or

exists(FunctionalExpr func | func.asMethod() = this)

}

override predicate isAbstract() {

// The combination `abstract default` isn't legal in Java,

// but it occurs when the Kotlin extractor records a default

// body, but the output class file in fact uses an abstract

// method and an associated static helper, which we don't

// extract as an implementation detail.

Callable.super.isAbstract() and not this.isDefault()

or

// JLS 9.4: An interface method lacking a `private`, `default`, or `static` modifier

// is implicitly abstract.

this.getDeclaringType() instanceof Interface and

not this.isPrivate() and

not this.isDefault() and

not this.isStatic()

}

override predicate isStrictfp() {

Callable.super.isStrictfp()

or

// JLS 8.1.1.3, JLS 9.1.1.2

this.getDeclaringType().isStrictfp()

}

/**

* Holds if this method is neither private nor a static interface method

* nor an initializer method, and hence could be inherited.

*/

predicate isInheritable() {

not this.isPrivate() and

not (this.isStatic() and this.getDeclaringType() instanceof Interface) and

not this instanceof InitializerMethod

}

/**

* Holds if this method is neither private nor static, and hence

* uses dynamic dispatch.

*/

predicate isVirtual() { not this.isPrivate() and not this.isStatic() }

/** Holds if this method can be overridden. */

predicate isOverridable() {

this.isVirtual() and

not this.isFinal() and

not this.getDeclaringType().isFinal()

}

/** Holds if this method is a Kotlin local function. */

predicate isLocal() { ktLocalFunction(this) }

/**

* Gets the Kotlin name of this method, that is either the name of this method, or

* if `JvmName` annotation was applied to the declaration, then the original name.

*/

string getKotlinName() {

ktFunctionOriginalNames(this, result)

or

not ktFunctionOriginalNames(this, _) and

result = this.getName()

}

override string getAPrimaryQlClass() { result = "Method" }

}

/** A method that is the same as its source declaration. */

class SrcMethod extends Method {

SrcMethod() { methods(this, _, _, _, _, this) }

/**

* All the methods that could possibly be called when this method

* is called. For class methods this includes the method itself and all its

* overriding methods (if any), and for interface methods this includes

* matching methods defined on or inherited by implementing classes.

*

* Only includes method implementations, not abstract or non-default interface methods.

* Native methods are included, since they have an implementation (just not in Java).

*/

SrcMethod getAPossibleImplementationOfSrcMethod() {

(

if this.getDeclaringType() instanceof Interface and this.isVirtual()

then implementsInterfaceMethod(result, this)

else result.getASourceOverriddenMethod*() = this

) and

(

// We allow empty method bodies for the local overlay variant to allow

// calls to methods only fully extracted in base.

isOverlay() or

exists(result.getBody()) or

result.hasModifier("native")

)

}

}

/**

* A _setter_ method is a method with the following properties:

*

* - it has exactly one parameter,

* - its body contains exactly one statement

* that assigns the value of the method parameter to a field

* declared in the same type as the method.

*/

class SetterMethod extends Method {

SetterMethod() {

this.getNumberOfParameters() = 1 and

exists(ExprStmt s, Assignment a |

s = this.getBody().(SingletonBlock).getStmt() and a = s.getExpr()

|

exists(Field f | f.getDeclaringType() = this.getDeclaringType() |

a.getDest() = f.getAnAccess() and

a.getSource() = this.getAParameter().getAnAccess()

)

)

}

/** Gets the field assigned by this setter method. */

Field getField() {

exists(Assignment a | a.getEnclosingCallable() = this | a.getDest() = result.getAnAccess())

}

}

/**

* A _getter_ method is a method with the following properties:

*

* - it has no parameters,

* - its body contains exactly one statement

* that returns the value of a field.

*/

class GetterMethod extends Method {

GetterMethod() {

this.hasNoParameters() and

exists(ReturnStmt s, Field f | s = this.getBody().(SingletonBlock).getStmt() |

s.getExpr() = f.getAnAccess()

)

}

/** Gets the field whose value is returned by this getter method. */

Field getField() {

exists(ReturnStmt r | r.getEnclosingCallable() = this | r.getExpr() = result.getAnAccess())

}

}

/**

* A finalizer method, with name `finalize`,

* return type `void` and no parameters.

*/

class FinalizeMethod extends Method {

FinalizeMethod() {

this.hasName("finalize") and

this.getReturnType().hasName("void") and

this.hasNoParameters()

}

}

/** A constructor is a particular kind of callable. */

class Constructor extends Callable, @constructor {

/** Holds if this is a default constructor, not explicitly declared in source code. */

predicate isDefaultConstructor() { isDefConstr(this) }

/** Holds if this is a constructor without parameters. */

predicate isParameterless() { this.getNumberOfParameters() = 0 }

override Constructor getSourceDeclaration() { constrs(this, _, _, _, _, result) }

override string getSignature() { constrs(this, _, result, _, _, _) }

override string getAPrimaryQlClass() { result = "Constructor" }

}

/**

* A compiler-generated initializer method (could be static or

* non-static), which is used to hold (static or non-static) field

* initializers, as well as explicit initializer blocks.

*/

abstract class InitializerMethod extends Method { }

/**

* A static initializer is a method that contains all static

* field initializations and static initializer blocks.

*/

class StaticInitializer extends InitializerMethod {

StaticInitializer() { this.hasName("<clinit>") }

}

/**

* An instance initializer is a method that contains field initializations

* and explicit instance initializer blocks.

*/

class InstanceInitializer extends InitializerMethod {

InstanceInitializer() { this.hasName("<obinit>") }

}

/** A field declaration that declares one or more class or instance fields. */

class FieldDeclaration extends ExprParent, @fielddecl, Annotatable {

/** Gets the access to the type of the field(s) in this declaration. */

Expr getTypeAccess() { result.getParent() = this }

/** Gets a field declared in this declaration. */

Field getAField() { fieldDeclaredIn(result, this, _) }

/** Gets the field declared at the specified (zero-based) position in this declaration */

Field getField(int idx) { fieldDeclaredIn(result, this, idx) }

/** Gets the number of fields declared in this declaration. */

int getNumField() { result = max(int idx | fieldDeclaredIn(_, this, idx) | idx) + 1 }

private string stringifyType() {

// Necessary because record fields are missing their type access.

if exists(this.getTypeAccess())

then result = this.getTypeAccess().toString()

else result = this.getAField().getType().toString()

}

override string toString() {

if this.getNumField() = 1

then result = this.stringifyType() + " " + this.getField(0) + ";"

else result = this.stringifyType() + " " + this.getField(0) + ", ...;"

}

override string getAPrimaryQlClass() { result = "FieldDeclaration" }

}

/** A class or instance field. */

class Field extends Member, ExprParent, @field, Variable {

/** Gets the declared type of this field. */

override Type getType() { fields(this, _, result, _) }

/** Gets the Kotlin type of this field. */

override KotlinType getKotlinType() { fieldsKotlinType(this, result) }

/** Gets the type in which this field is declared. */

override RefType getDeclaringType() { fields(this, _, _, result) }

/**

* Gets the field declaration in which this field is declared.

*

* Note that this declaration is only available if the field occurs in source code.

*/

FieldDeclaration getDeclaration() { result.getAField() = this }

/** Gets the initializer expression of this field, if any. */

override Expr getInitializer() {

exists(AssignExpr e, InitializerMethod im, ExprStmt exprStmt |

e.getDest() = this.getAnAccess() and

e.getSource() = result and

exprStmt.getExpr() = e and

// This check also rules out assignments in explicit initializer blocks

// (CodeQL models explicit initializer blocks as BlockStmt in initializer methods)

exprStmt.getParent() = im.getBody()

)

or

// Kotlin initializers are more general than Java's, in that they may refer to

// primary constructor parameters. This identifies a syntactic initializer, so

// `class A { val y = 1 }` is an initializer, as is `class B(x: Int) { val y = x }`,

// but `class C { var x: Int; init { x = 1 } }` is not, and neither is

// `class D { var x: Int; constructor(y: Int) { x = y } }`

exists(KtInitializerAssignExpr e |

e.getDest() = this.getAnAccess() and

e.getSource() = result

)

}

/**

* DEPRECATED: The result is always `this`.

*/

deprecated Field getSourceDeclaration() { result = this }

/** DEPRECATED: This always holds. */

deprecated predicate isSourceDeclaration() { any() }

override predicate isPublic() {

Member.super.isPublic()

or

// JLS 9.3: Every field declaration in the body of an interface is

// implicitly public, static, and final

this.getDeclaringType() instanceof Interface

}

override predicate isStatic() {

Member.super.isStatic()

or

// JLS 9.3: Every field declaration in the body of an interface is

// implicitly public, static, and final

this.getDeclaringType() instanceof Interface

}

override predicate isFinal() {

Member.super.isFinal()

or

// JLS 9.3: Every field declaration in the body of an interface is

// implicitly public, static, and final

this.getDeclaringType() instanceof Interface

}

/** Cast this field to a class that provides access to metrics information. */

MetricField getMetrics() { result = this }

override string getAPrimaryQlClass() { result = "Field" }

}

overlay[local]

private class DiscardableField extends DiscardableReferableLocatable, @field { }

/** An instance field. */

class InstanceField extends Field {

InstanceField() { not this.isStatic() }

}

/** A Kotlin property. */

class Property extends Element, Modifiable, @kt_property {

/** Gets the getter method for this property, if any. */

Method getGetter() { ktPropertyGetters(this, result) }

/** Gets the setter method for this property, if any. */

Method getSetter() { ktPropertySetters(this, result) }

/** Gets the backing field for this property, if any. */

Field getBackingField() { ktPropertyBackingFields(this, result) }

override string getAPrimaryQlClass() { result = "Property" }

}

/** A Kotlin delegated property. */

class DelegatedProperty extends Property {

Variable underlying;

DelegatedProperty() { ktPropertyDelegates(this, underlying) }

/** Holds if this delegated property is declared as a local variable. */

predicate isLocal() { underlying instanceof LocalVariableDecl }

/** Gets the underlying local variable or field to which this property is delegating the calls. */

Variable getDelegatee() { result = underlying }

override string getAPrimaryQlClass() { result = "DelegatedProperty" }

}

/** A Kotlin extension function. */

class ExtensionMethod extends Method {

Type extendedType;

KotlinType extendedKotlinType;

ExtensionMethod() { ktExtensionFunctions(this, extendedType, extendedKotlinType) }

/** Gets the type being extended by this method. */

Type getExtendedType() { result = extendedType }

/** Gets the Kotlin type being extended by this method. */

KotlinType getExtendedKotlinType() { result = extendedKotlinType }

override string getAPrimaryQlClass() { result = "ExtensionMethod" }

/**

* Gets the index of the parameter that is the extension receiver. This is typically index 0. In case of `$default`

* extension methods that are defined as members, the index is 1. Index 0 is the dispatch receiver of the `$default`

* method.

*/

int getExtensionReceiverParameterIndex() {

if

exists(Method src |

this = src.getKotlinParameterDefaultsProxy() and

src.getNumberOfParameters() = this.getNumberOfParameters() - 3 // 2 extra parameters + 1 dispatch receiver

)

then result = 1

else result = 0

}

}

overlay[local]

private class DiscardableAnonymousMethod extends DiscardableLocatable, @method {

DiscardableAnonymousMethod() {

exists(@classorinterface c | methods(this, _, _, _, c, _) and isAnonymClass(c, _))

}

}

overlay[local]

private class DiscardableMethod extends DiscardableReferableLocatable, @method { }