Skip to content

Commit

Permalink
Add OverridePlugin tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@kjonescertinia
kjonescertinia committed Aug 10, 2024
1 parent ae73f43 commit a3e2877
Show file tree
Hide file tree
Showing 4 changed files with 323 additions and 24 deletions.
65 changes: 45 additions & 20 deletions jvm/src/main/scala/com/nawforce/apexlink/plugins/OverridePlugin.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,51 +4,76 @@
package com.nawforce.apexlink.plugins

import com.nawforce.apexlink.cst._
import com.nawforce.apexlink.plugins.OverridePlugin.extensibleModifiers
import com.nawforce.apexlink.types.apex.ApexMethodLike
import com.nawforce.apexlink.types.core.DependentType
import com.nawforce.pkgforce.diagnostics.{Diagnostic, ERROR_CATEGORY, Issue}
import com.nawforce.pkgforce.modifiers._

import scala.annotation.unused

/** Provides plugin for generating unused warnings on a single type
/** Plugin for detecting where a private method override is occurring in pre-v61 code. Flags both super class
* and base class methods to make easier to spot.
*
* @param td type being handled by this plugin
*/
@unused
class OverridePlugin(td: DependentType) extends Plugin(td) {

override def onEnumValidated(td: EnumDeclaration): Seq[DependentType] = Seq.empty

override def onInterfaceValidated(td: InterfaceDeclaration): Seq[DependentType] = Seq.empty

override def onClassValidated(td: ClassDeclaration): Seq[DependentType] = {
// Ignore methods in test classes
if (td.inTest)
// Bail early if not extending or virtual/abstract
if (td.modifiers.intersect(extensibleModifiers).isEmpty && td.superClass.isEmpty)
return Seq.empty

// Hack: Analysis requires a methodMap as it establishes shadow relationships
td.methodMap

td.localMethods
.flatMap {
case am: ApexMethodLike if am.visibility == PRIVATE_MODIFIER && am.shadowedBy.nonEmpty =>
Some(am)
case _ => None
}
.map(method => {
new Issue(
method.location.path,
Diagnostic(
ERROR_CATEGORY,
method.idLocation,
s"Override of private abstract/virtual method will fail in v61, '${method.signature}'"
.collect { case m: ApexMethodLike => m }
.foreach(method => {
// This private method is being overridden
if (method.visibility == PRIVATE_MODIFIER && method.shadowedBy.nonEmpty) {
val overrides = method.shadowedBy.flatMap(_.thisTypeIdOpt).map(_.toString).mkString(", ")
td.module.pkg.org.issues.log(
new Issue(
method.location.path,
Diagnostic(
ERROR_CATEGORY,
method.idLocation,
s"The overrides of this private method will fail in v61, see $overrides"
)
)
)
)
}

// This method is overriding a private method
findPrivateShadow(method)
.foreach(shadow => {
td.module.pkg.org.issues.log(
new Issue(
method.location.path,
Diagnostic(
ERROR_CATEGORY,
method.idLocation,
s"This override of a private method will fail in v61, see ${shadow.location.toString}"
)
)
)
})
})
.foreach(td.module.pkg.org.issues.log)

// No dependent processing needed, this is a standalone analysis
Seq.empty
}

private def findPrivateShadow(method: ApexMethodLike): Option[ApexMethodLike] = {
val shadows = method.shadows.collect { case m: ApexMethodLike => m }
val privateShadow = shadows.find(_.visibility == PRIVATE_MODIFIER)
privateShadow.orElse(shadows.collectFirst(Function.unlift(findPrivateShadow)))
}
}

object OverridePlugin {
final val extensibleModifiers = Seq(ABSTRACT_MODIFIER, VIRTUAL_MODIFIER)
}
6 changes: 3 additions & 3 deletions jvm/src/test/scala/com/nawforce/apexlink/TestHelper.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,7 +22,7 @@ import com.nawforce.apexlink.api.{
TypeSummary
}
import com.nawforce.apexlink.org.{OPM, OrgInfo}
import com.nawforce.apexlink.plugins.{PluginsManager, UnusedPlugin}
import com.nawforce.apexlink.plugins.{Plugin, PluginsManager, UnusedPlugin}
import com.nawforce.apexlink.rpc.{LocationLink, TargetLocation}
import com.nawforce.apexlink.types.apex.{ApexClassDeclaration, ApexFullDeclaration, FullDeclaration}
import com.nawforce.apexlink.types.core.TypeDeclaration
Expand Down Expand Up @@ -59,8 +59,8 @@ trait TestHelper {
}
}

def createOrgWithUnused(path: PathLike): OPM.OrgImpl = {
val plugins = PluginsManager.overridePlugins(Seq(classOf[UnusedPlugin]))
def createOrgWithPlugin(path: PathLike, cls: Class[_ <: Plugin]): OPM.OrgImpl = {
val plugins = PluginsManager.overridePlugins(Seq(cls))
try {
ParserHelper.setParser()
defaultOrg = Org.newOrg(path).asInstanceOf[OPM.OrgImpl]
Expand Down
269 changes: 269 additions & 0 deletions jvm/src/test/scala/com/nawforce/apexlink/plugin/OverrideTest.scala
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,269 @@
/*
* Copyright (c) 2024 Certinia Inc. All rights reserved.
*/

package com.nawforce.apexlink.plugin
import com.nawforce.apexlink.TestHelper
import com.nawforce.apexlink.org.OPM
import com.nawforce.apexlink.plugins.OverridePlugin
import com.nawforce.pkgforce.path.PathLike
import com.nawforce.runtime.FileSystemHelper
import org.scalatest.Inspectors.forAll
import org.scalatest.funsuite.AnyFunSuite
import org.scalatest.matchers.should.Matchers

class OverrideTest extends AnyFunSuite with Matchers with TestHelper {

def createOrgWithOverride(root: PathLike): OPM.OrgImpl = {
createOrgWithPlugin(root, classOf[OverridePlugin])
}

def orgIssuesFor(org: OPM.OrgImpl, path: PathLike): String = {
val messages = org.issueManager.issuesForFileInternal(path).map(_.asString()).mkString("\n")
if (messages.nonEmpty) messages + "\n" else ""
}

forAll(Set("", "private")) { baseVisibility =>
val baseVisibilityDescribe = if (baseVisibility.isEmpty) "implicit private" else "private"
forAll(Set("private", "protected", "public")) { overrideVisibility =>
test(s"Override $baseVisibilityDescribe with $overrideVisibility") {
FileSystemHelper.run(
Map(
"Base.cls" -> s"public virtual class Base {$baseVisibility void foo() {}}",
"Over.cls" -> s"public class Over extends Base {$overrideVisibility void foo() {}}"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
orgIssuesFor(org, root.join("Base.cls")) should include(
"The overrides of this private method will fail in v61, see Over\n"
)
orgIssuesFor(org, root.join("Over.cls")) should include(
"This override of a private method will fail in v61, see /Base.cls: line 1 at"
)
}
}

test(s"Override $baseVisibilityDescribe with $overrideVisibility in same file") {
FileSystemHelper.run(
Map(
"Base.cls" -> s"public virtual class Base {$baseVisibility void foo() {} public class Over extends Base {$overrideVisibility void foo() {}}}"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
orgIssuesFor(org, root.join("Base.cls")) should include(
"Method 'foo' can not override non-virtual method\n"
)
}
}

test(s"Override $baseVisibilityDescribe virtual with $overrideVisibility") {
FileSystemHelper.run(
Map(
"Base.cls" -> s"public virtual class Base {$baseVisibility virtual void foo() {}}",
"Over.cls" -> s"public class Over extends Base {$overrideVisibility void foo() {}}"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
orgIssuesFor(org, root.join("Base.cls")) should include(
"The overrides of this private method will fail in v61, see Over\n"
)
orgIssuesFor(org, root.join("Over.cls")) should include(
"This override of a private method will fail in v61, see /Base.cls: line 1"
)
}
}

test(s"Override $baseVisibilityDescribe virtual with $overrideVisibility in same file") {
FileSystemHelper.run(
Map(
"Base.cls" -> s"public virtual class Base {private virtual void foo() {} public class Over extends Base {$overrideVisibility override void foo() {}}}"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
orgIssuesFor(org, root.join("Base.cls")) should include(
"The overrides of this private method will fail in v61, see Base.Over\n"
)
orgIssuesFor(org, root.join("Base.cls")) should include(
"This override of a private method will fail in v61, see /Base.cls: line 1 at"
)
}
}

test(s"Override $baseVisibilityDescribe abstract with $overrideVisibility") {
FileSystemHelper.run(
Map(
"Base.cls" -> s"public abstract class Base {$baseVisibility abstract void foo();}",
"Over.cls" -> s"public class Over extends Base {$overrideVisibility void foo() {}}"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
orgIssuesFor(org, root.join("Base.cls")) should include(
"The overrides of this private method will fail in v61, see Over\n"
)
orgIssuesFor(org, root.join("Over.cls")) should include(
"This override of a private method will fail in v61, see /Base.cls: line 1"
)
}
}

test(s"Override $baseVisibilityDescribe abstract with $overrideVisibility in same file") {
FileSystemHelper.run(
Map(
"Base.cls" -> s"public abstract class Base {private abstract void foo(); public class Over extends Base {$overrideVisibility override void foo() {}}}"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
orgIssuesFor(org, root.join("Base.cls")) should include(
"The overrides of this private method will fail in v61, see Base.Over\n"
)
orgIssuesFor(org, root.join("Base.cls")) should include(
"This override of a private method will fail in v61, see /Base.cls: line 1 at"
)
}
}
}
}

test(s"Three trier private/private/private override ") {
FileSystemHelper.run(
Map(
"A.cls" -> s"public virtual class A {private void foo() {} }",
"B.cls" -> s"public virtual class B extends A {private void foo() {} }",
"C.cls" -> s"public virtual class C extends B {private void foo() {} }"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
assert(
orgIssuesFor(org, root.join("A.cls"))
== "Error: line 1 at 37-40: The overrides of this private method will fail in v61, see B\n"
)
assert(
orgIssuesFor(org, root.join("B.cls"))
== "Error: line 1 at 47-50: This override of a private method will fail in v61, see /A.cls: line 1 at 32-45\n" +
"Error: line 1 at 47-50: The overrides of this private method will fail in v61, see C\n"
)
assert(
orgIssuesFor(org, root.join("C.cls"))
== "Error: line 1 at 47-50: This override of a private method will fail in v61, see /B.cls: line 1 at 42-55\n"
)
}
}

test(s"Three trier private/protected/protected override ") {
FileSystemHelper.run(
Map(
"A.cls" -> s"public virtual class A {private void foo() {} }",
"B.cls" -> s"public virtual class B extends A {protected virtual void foo() {} }",
"C.cls" -> s"public virtual class C extends B {protected override void foo() {} }"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
assert(
orgIssuesFor(org, root.join("A.cls"))
== "Error: line 1 at 37-40: The overrides of this private method will fail in v61, see B\n"
)
assert(
orgIssuesFor(org, root.join("B.cls"))
== "Error: line 1 at 57-60: This override of a private method will fail in v61, see /A.cls: line 1 at 32-45\n"
)
assert(
orgIssuesFor(org, root.join("C.cls"))
== "Error: line 1 at 58-61: This override of a private method will fail in v61, see /A.cls: line 1 at 32-45\n"
)
}
}

test(s"Three trier private/protected/public override ") {
FileSystemHelper.run(
Map(
"A.cls" -> "public virtual class A {private void foo() {} }",
"B.cls" -> "public virtual class B extends A {protected virtual void foo() {} }",
"C.cls" -> "public virtual class C extends B {public override void foo() {} }"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
assert(
orgIssuesFor(org, root.join("A.cls"))
== "Error: line 1 at 37-40: The overrides of this private method will fail in v61, see B\n"
)
assert(
orgIssuesFor(org, root.join("B.cls"))
== "Error: line 1 at 57-60: This override of a private method will fail in v61, see /A.cls: line 1 at 32-45\n"
)
assert(
orgIssuesFor(org, root.join("C.cls"))
== "Error: line 1 at 55-58: This override of a private method will fail in v61, see /A.cls: line 1 at 32-45\n"
)
}
}

test(s"Three trier private/public/public override ") {
FileSystemHelper.run(
Map(
"A.cls" -> "public virtual class A {private void foo() {} }",
"B.cls" -> "public virtual class B extends A {public virtual void foo() {} }",
"C.cls" -> "public virtual class C extends B {public override void foo() {} }"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
assert(
orgIssuesFor(org, root.join("A.cls"))
== "Error: line 1 at 37-40: The overrides of this private method will fail in v61, see B\n"
)
assert(
orgIssuesFor(org, root.join("B.cls"))
== "Error: line 1 at 54-57: This override of a private method will fail in v61, see /A.cls: line 1 at 32-45\n"
)
assert(
orgIssuesFor(org, root.join("C.cls"))
== "Error: line 1 at 55-58: This override of a private method will fail in v61, see /A.cls: line 1 at 32-45\n"
)
}
}

test(s"Dual overrides") {
FileSystemHelper.run(
Map(
"A.cls" -> "public virtual class A {private void foo() {} }",
"B.cls" -> "public virtual class B extends A {private void foo() {} }",
"C.cls" -> "public virtual class C extends A {private void foo() {} }"
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
assert(
orgIssuesFor(org, root.join("A.cls"))
== "Error: line 1 at 37-40: The overrides of this private method will fail in v61, see B, C\n"
)
assert(
orgIssuesFor(org, root.join("B.cls"))
== "Error: line 1 at 47-50: This override of a private method will fail in v61, see /A.cls: line 1 at 32-45\n"
)
assert(
orgIssuesFor(org, root.join("C.cls"))
== "Error: line 1 at 47-50: This override of a private method will fail in v61, see /A.cls: line 1 at 32-45\n"
)
}
}

test(s"Dual overrides (same file)") {
FileSystemHelper.run(
Map(
"A.cls" ->
"""public virtual class A {private virtual void foo() {}
| public virtual class B extends A {private override void foo() {} }
| public virtual class C extends A {private override void foo() {} }
|}
|""".stripMargin
)
) { root: PathLike =>
val org = createOrgWithOverride(root)
assert(
orgIssuesFor(org, root.join("A.cls"))
== "Error: line 1 at 45-48: The overrides of this private method will fail in v61, see A.B, A.C\n" +
"Error: line 2 at 57-60: This override of a private method will fail in v61, see /A.cls: line 1 at 40-53\n" +
"Error: line 3 at 57-60: This override of a private method will fail in v61, see /A.cls: line 1 at 40-53\n"
)
}
}

}
Loading

0 comments on commit a3e2877

Please sign in to comment.