/**
 * Generates java stubs for use in test code.
 *
 * Extend the abstract class `GeneratedDeclaration` with the declarations that should be generated.
 * This will generate stubs for all the required dependencies as well.
 */

import java

/** Holds if `id` is a valid Java identifier. */
bindingset[id]
private predicate isValidIdentifier(string id) { id.regexpMatch("[\\w_$]+") }

/** A type that should be in the generated code. */
abstract private class GeneratedType extends ClassOrInterface {
  GeneratedType() {
    not this instanceof AnonymousClass and
    not this.isLocal() and
    not this.getPackage() instanceof ExcludedPackage and
    isValidIdentifier(this.getName())
  }

  private string stubKeyword() {
    this instanceof Interface and
    (if this instanceof AnnotationType then result = "@interface" else result = "interface")
    or
    this instanceof Class and
    (if this instanceof EnumType then result = "enum" else result = "class")
  }

  private string stubAbstractModifier() {
    if this.(Class).isAbstract() then result = "abstract " else result = ""
  }

  private string stubStaticModifier() {
    if this.(NestedType).isStatic() then result = "static " else result = ""
  }

  private string stubAccessibilityModifier() {
    if this.isPublic() then result = "public " else result = ""
  }

  private string stubAnnotations() {
    if exists(this.(AnnotationType).getAnAnnotation())
    then
      result =
        concat(Annotation an |
            this.(AnnotationType).getAnAnnotation() = an
          |
            stubAnnotation(an), "\n" order by an.getType().getQualifiedName()
          ) + "\n"
    else result = ""
  }

  /** Gets the entire Java stub code for this type. */
  final string getStub() {
    result =
      this.stubAnnotations() + this.stubAbstractModifier() + this.stubStaticModifier() +
        this.stubAccessibilityModifier() + this.stubKeyword() + " " + this.getName() +
        stubGenericArguments(this, true) + this.stubBaseTypesString() + "\n{\n" + this.stubMembers()
        + "}"
  }

  private RefType getAnInterestingBaseType() {
    result = this.getASupertype() and
    not result instanceof TypeObject and
    not this instanceof EnumType and
    // generic types have their source declaration (the corresponding raw type) as a supertype of themselves
    result.getSourceDeclaration() != this
  }

  private string stubBaseTypesString() {
    if exists(this.getAnInterestingBaseType())
    then
      exists(string cls, string interface, string int_kw | result = cls + int_kw + interface |
        (
          if exists(this.getAnInterestingBaseType().(Class))
          then cls = " extends " + stubTypeName(this.getAnInterestingBaseType().(Class))
          else cls = ""
        ) and
        (
          if
            exists(this.getAnInterestingBaseType().(Interface)) and
            not this instanceof AnnotationType
          then (
            (if this instanceof Class then int_kw = " implements " else int_kw = " extends ") and
            interface = concat(stubTypeName(this.getAnInterestingBaseType().(Interface)), ", ")
          ) else (
            int_kw = "" and interface = ""
          )
        )
      )
    else result = ""
  }

  language[monotonicAggregates]
  private string stubMembers() {
    result =
      stubEnumConstants(this) + stubFakeConstructor(this) +
        concat(Member m | m = this.getAGeneratedMember() | stubMember(m))
  }

  private Member getAGeneratedMember() {
    (
      not result instanceof NestedType and
      result.getDeclaringType() = this
      or
      exists(NestedType nt | result = nt |
        nt = nt.getSourceDeclaration() and
        nt.getEnclosingType().getSourceDeclaration() = this
      )
    ) and
    not result.isPrivate() and
    not result.isPackageProtected() and
    not result instanceof StaticInitializer and
    not result instanceof InstanceInitializer and
    isValidIdentifier(result.getName())
  }

  final Type getAGeneratedType() {
    result = this.getAnInterestingBaseType() or
    result = this.getAGeneratedMember().(Callable).getReturnType() or
    result = this.getAGeneratedMember().(Callable).getAParameter().getType() or
    result = this.getAGeneratedMember().(Field).getType() or
    result = this.getAGeneratedMember().(NestedType) or
    result = this.(AnnotationType).getAnAnnotation().getType() or
    result = this.(AnnotationType).getAnAnnotation().getValue(_).getType() or
    result = this.(AnnotationType).getAnAnnotation().getAnArrayValue(_).getType()
  }
}

/**
 * A declaration that should be generated.
 * This is extended in client code to identify the actual
 * declarations that should be generated.
 */
abstract class GeneratedDeclaration extends Element { }

private class IndirectType extends GeneratedType {
  IndirectType() {
    this.getASubtype() instanceof GeneratedType
    or
    this.(GenericType).getAParameterizedType() instanceof GeneratedType
    or
    exists(GeneratedType t |
      this = getAContainedType(t.getAGeneratedType()).(RefType).getSourceDeclaration()
    )
    or
    this.getSourceDeclaration() instanceof GeneratedType
    or
    this = any(GeneratedType t).getSourceDeclaration()
    or
    exists(GeneratedDeclaration decl |
      decl.(Member).getDeclaringType().getSourceDeclaration() = this
    )
    or
    this.(NestedType).getEnclosingType() instanceof GeneratedType
    or
    exists(NestedType nt | nt instanceof GeneratedType and this = nt.getEnclosingType())
  }
}

private class RootGeneratedType extends GeneratedType {
  RootGeneratedType() { this = any(GeneratedDeclaration decl).(RefType).getSourceDeclaration() }
}

private Type getAContainedType(Type t) {
  result = t
  or
  result = getAContainedType(t.(ParameterizedType).getATypeArgument())
  or
  result = getAContainedType(t.(Array).getElementType())
  or
  result = getAContainedType(t.(BoundedType).getATypeBound().getType())
}

/**
 * Specify packages to exclude.
 * Do not generate any types from these packages.
 */
abstract class ExcludedPackage extends Package { }

/** Exclude types from the standard library. */
private class DefaultLibs extends ExcludedPackage {
  DefaultLibs() { this.getName().matches(["java.%", "jdk.%", "sun.%"]) }
}

private string stubAccessibility(Member m) {
  if m.getDeclaringType() instanceof Interface
  then result = ""
  else
    if m.isPublic()
    then result = "public "
    else
      if m.isProtected()
      then result = "protected "
      else
        if m.isPrivate()
        then result = "private "
        else
          if m.isPackageProtected()
          then result = ""
          else result = "unknown-accessibility"
}

private string stubModifiers(Member m) {
  result = stubAccessibility(m) + stubStaticOrFinal(m) + stubAbstractOrDefault(m)
}

private string stubStaticOrFinal(Member m) {
  if m.(Modifiable).isStatic()
  then result = "static "
  else
    if m.(Modifiable).isFinal()
    then result = "final "
    else result = ""
}

private string stubAbstractOrDefault(Member m) {
  if m.getDeclaringType() instanceof Interface
  then if m.isDefault() then result = "default " else result = ""
  else
    if m.isAbstract()
    then result = "abstract "
    else result = ""
}

private string stubTypeName(Type t) {
  if t instanceof PrimitiveType
  then result = t.getName()
  else
    if t instanceof VoidType
    then result = "void"
    else
      if t instanceof TypeVariable
      then result = t.getName()
      else
        if t instanceof Wildcard
        then result = "?" + stubTypeBound(t)
        else
          if t instanceof Array
          then result = stubTypeName(t.(Array).getComponentType()) + "[]"
          else
            if t instanceof ClassOrInterface
            then
              result =
                stubQualifier(t) + t.(RefType).getSourceDeclaration().getName() +
                  stubGenericArguments(t, false)
            else result = "<error>"
}

language[monotonicAggregates]
private string stubTypeBound(BoundedType t) {
  if not exists(t.getATypeBound())
  then result = ""
  else
    exists(string kw, string bounds | result = kw + bounds |
      (if t.(Wildcard).hasLowerBound() then kw = " super " else kw = " extends ") and
      bounds =
        concat(TypeBound b |
          b = t.getATypeBound()
        |
          stubTypeName(b.getType()), " & " order by b.getPosition()
        )
    )
}

private string maybeStubTypeBound(BoundedType t, boolean typeVarBounds) {
  typeVarBounds = true and
  result = stubTypeBound(t)
  or
  typeVarBounds = false and
  result = ""
}

private string stubQualifier(RefType t) {
  if t instanceof NestedType
  then
    exists(RefType et | et = t.(NestedType).getEnclosingType().getSourceDeclaration() |
      result = stubQualifier(et) + et.getName() + "."
    )
  else
    if needsPackageName(t)
    then result = t.getPackage().getName() + "."
    else result = ""
}

pragma[nomagic]
private predicate needsPackageNameHelper(RefType t, GeneratedTopLevel top, string name) {
  t.getSourceDeclaration() =
    pragma[only_bind_out]([getAReferencedType(top), top].getSourceDeclaration()) and
  name = t.getName()
}

pragma[nomagic]
private predicate describesMultipleTypes(GeneratedTopLevel top, string name) {
  2 <= strictcount(RefType t | needsPackageNameHelper(t, top, name))
}

/**
 * Holds if `t` may clash with another type of the same name, so should be referred to using the fully qualified name
 */
private predicate needsPackageName(RefType t) {
  exists(GeneratedTopLevel top, string name |
    needsPackageNameHelper(t, top, name) and
    describesMultipleTypes(top, name)
  )
}

language[monotonicAggregates]
private string stubGenericArguments(RefType t, boolean typeVarBounds) {
  typeVarBounds = [true, false] and
  if t instanceof GenericType
  then
    result =
      "<" +
        concat(int n, TypeVariable tv |
          tv = t.(GenericType).getTypeParameter(n)
        |
          tv.getName() + maybeStubTypeBound(tv, typeVarBounds), ", " order by n
        ) + ">"
  else
    if t instanceof ParameterizedType
    then
      result =
        "<" +
          concat(int n, Type tpar |
            tpar = t.(ParameterizedType).getTypeArgument(n)
          |
            stubTypeName(tpar), ", " order by n
          ) + ">"
    else result = ""
}

private string stubGenericCallableParams(Callable m) {
  if m instanceof GenericCallable
  then
    result =
      "<" +
        concat(int n, TypeVariable param |
          param = m.(GenericCallable).getTypeParameter(n)
        |
          param.getName() + stubTypeBound(param), ", " order by n
        ) + "> "
  else result = ""
}

private string stubImplementation(Callable c) {
  if c.isAbstract()
  then result = ";"
  else
    if c instanceof Constructor or c.getReturnType() instanceof VoidType
    then result = "{}"
    else result = "{ return " + stubDefaultValue(c.getReturnType()) + "; }"
}

private string stubDefaultValue(Type t) {
  if t instanceof RefType
  then result = "null"
  else
    if t instanceof CharacterType
    then result = "'0'"
    else
      if t instanceof BooleanType
      then result = "false"
      else
        if t instanceof NumericType
        then result = "0"
        else result = "<error>"
}

private string stubParameters(Callable c) {
  result =
    concat(int i, Parameter param |
      param = c.getParameter(i)
    |
      stubParameter(param), ", " order by i
    )
}

private string stubParameter(Parameter p) {
  exists(Type t, string suff | result = stubTypeName(t) + suff + " " + p.getName() |
    if p.isVarargs()
    then (
      t = p.getType().(Array).getComponentType() and
      suff = "..."
    ) else (
      t = p.getType() and suff = ""
    )
  )
}

private string stubEnumConstants(RefType t) {
  if t instanceof EnumType
  then
    exists(EnumType et | et = t |
      result =
        "    " + concat(EnumConstant c | c = et.getAnEnumConstant() | c.getName(), ", ") + ";\n"
    )
  else result = ""
}

// Holds if the member is to be excluded from stubMember
private predicate excludedMember(Member m) {
  m instanceof EnumConstant
  or
  m.(Method).getDeclaringType() instanceof EnumType and
  m.hasName(["values", "valueOf"]) and
  m.isStatic()
  or
  exists(Parameter p |
    p = m.(Method).getAParameter() and
    p.getType().fromSource() and
    not p.getType().(RefType).isPublic()
  )
}

private string stubMember(Member m) {
  if excludedMember(m)
  then result = ""
  else (
    result =
      "    " + stubModifiers(m) + stubGenericCallableParams(m) +
        stubTypeName(m.(Method).getReturnType()) + " " + m.getName() + "(" + stubParameters(m) + ")"
        + stubImplementation(m) + "\n"
    or
    m instanceof Constructor and
    result =
      "    " + stubModifiers(m) + stubGenericCallableParams(m) + m.getName() + "(" +
        stubParameters(m) + ")" + stubImplementation(m) + "\n"
    or
    result =
      "    " + stubModifiers(m) + stubTypeName(m.(Field).getType()) + " " + m.getName() + " = " +
        stubDefaultValue(m.(Field).getType()) + ";\n"
    or
    result = indent(m.(NestedType).(GeneratedType).getStub())
  )
}

language[monotonicAggregates]
private string stubAnnotation(Annotation a) {
  if exists(a.getValue(_))
  then
    result =
      "@" + a.getType().getName() + "(" +
        concat(string name, Expr value |
          value = a.getValue(name)
        |
          name + "=" + stubAnnotationValue(value), ","
        ) + ")"
  else result = "@" + a.getType().getName()
}

language[monotonicAggregates]
private string stubAnnotationValue(Expr value) {
  result = value.(FieldAccess).getField().getQualifiedName()
  or
  (
    value instanceof Literal or
    value instanceof CompileTimeConstantExpr
  ) and
  if value instanceof StringLiteral
  then result = "\"\""
  else result = stubDefaultValue(value.getType())
  or
  result = stubAnnotation(value)
  or
  result = value.(TypeLiteral).getReferencedType().getName() + ".class"
  or
  value instanceof ArrayInit and
  result =
    "{" +
      concat(int i, Expr arrayElement |
        i >= 0 and
        arrayElement = value.(ArrayInit).getInit(i)
      |
        stubAnnotationValue(arrayElement), "," order by i
      ) + "}"
}

bindingset[s]
private string indent(string s) { result = "    " + s.replaceAll("\n", "\n    ") + "\n" }

// If a class's superclass doesn't have a no-arg constructor, then it won't compile when its constructor's bodies are stubbed
// So we synthesise no-arg constructors for each generated type that doesn't have one.
private string stubFakeConstructor(RefType t) {
  if not t instanceof Class
  then result = ""
  else
    exists(string mod |
      // this won't conflict with any existing private constructors, since we don't generate stubs for any private members.
      if t instanceof EnumType then mod = "    private " else mod = "    protected "
    |
      if hasNoArgConstructor(t) then result = "" else result = mod + t.getName() + "() {}\n"
    )
}

private predicate hasNoArgConstructor(Class t) {
  exists(Constructor c | c.getDeclaringType() = t |
    c.getNumberOfParameters() = 0 and
    not c.isPrivate()
  )
}

private RefType getAReferencedType(RefType t) {
  result = t.(GeneratedType).getAGeneratedType()
  or
  result =
    getAReferencedType(any(NestedType nt |
        nt.getEnclosingType().getSourceDeclaration() = t.getSourceDeclaration()
      ))
  or
  exists(RefType t1 | t1 = getAReferencedType(t) |
    result = t1.(NestedType).getEnclosingType()
    or
    result = t1.getSourceDeclaration()
    or
    result = t1.(ParameterizedType).getATypeArgument()
    or
    result = t1.(Array).getComponentType()
    or
    result = t1.(BoundedType).getATypeBound().getType()
  )
}

/** A top level type whose file should be stubbed */
class GeneratedTopLevel extends TopLevelType instanceof GeneratedType {
  GeneratedTopLevel() { this = this.(ClassOrInterface).getSourceDeclaration() }

  private TopLevelType getAnImportedType() {
    result = getAReferencedType(this).getSourceDeclaration() and
    not needsPackageName(result) // use the fully qualified name rather than importing it if it may cause name clashes
  }

  private string stubAnImport() {
    exists(ClassOrInterface t, string pkg, string name |
      t = this.getAnImportedType() and
      t.hasQualifiedName(pkg, name) and
      t != this and
      pkg != "java.lang"
    |
      result = "import " + pkg + "." + name + ";\n"
    )
  }

  private string stubImports() { result = concat(this.stubAnImport()) + "\n" }

  private string stubPackage() {
    if this.getPackage().getName() != ""
    then result = "package " + this.getPackage().getName() + ";\n\n"
    else result = ""
  }

  private string stubComment() {
    result =
      "// Generated automatically from " + this.getQualifiedName() + " for testing purposes\n\n"
  }

  /** Creates a full stub for the file containing this type. */
  string stubFile() {
    result = this.stubComment() + this.stubPackage() + this.stubImports() + super.getStub() + "\n"
  }
}