Add support for exported methods

frontends/benchmarks/dotty-specific/invalid/ExportedMethods1.scala

@@ -0,0 +1,20 @@
+object ExportedMethods1 {
+  case class Counter(var x: BigInt) {
+    def add(y: BigInt): Unit = {
+      require(y >= 0)
+      x += y
+    }
+  }
+
+  case class Base(cnt: Counter) {
+    export cnt.*
+  }
+
+  case class Wrapper(base: Base) {
+    export base.*
+
+    def addWith(y: BigInt): Unit = {
+      add(y) // invalid
+    }
+  }
+}

frontends/benchmarks/dotty-specific/invalid/ExportedMethods2.scala

@@ -0,0 +1,11 @@
+object ExportedMethods2 {
+  import ExportedMethodsExt.SimpleCounter.*
+
+  case class Wrapper(base: Base) {
+    export base.*
+
+    def addWith(y: BigInt): Unit = {
+      add(y) // invalid
+    }
+  }
+}

frontends/benchmarks/dotty-specific/invalid/ExportedMethods3.scala

@@ -0,0 +1,11 @@
+object ExportedMethods3 {
+  import ExportedMethodsExt.CounterWithInvariant.*
+
+  case class Wrapper(base: Base) {
+    export base.*
+
+    def addWith(y: BigInt): Unit = {
+      x = y
+    }
+  }
+}

frontends/benchmarks/dotty-specific/invalid/ExportedMethodsExt.scala

@@ -0,0 +1,87 @@
+object ExportedMethodsExt {
+
+  // This object is used for the other ExportedMethods
+  // but we need to have at least one invalid VC to pass the "invalid" test suite
+  def dummyInvalid(x: BigInt): Unit = {
+    assert(x == 0)
+  }
+
+  object SimpleCounter {
+    case class Counter(var x: BigInt) {
+      def add(y: BigInt): Unit = {
+        require(y >= 0)
+        x += y
+      }
+
+      def parametricAdd[T](y: BigInt, t: T): Unit = {
+        require(y >= 0)
+        x += y
+      }
+    }
+
+    case class Base(cnt: Counter) {
+      export cnt.*
+    }
+  }
+
+  object CounterWithInvariant {
+    case class Counter(var x: BigInt) {
+      require(x >= 0)
+
+      def add(y: BigInt): Unit = {
+        require(y >= 0)
+        x += y
+      }
+
+      def parametricAdd[T](y: BigInt, t: T): Unit = {
+        require(y >= 0)
+        x += y
+      }
+    }
+
+    case class Base(cnt: Counter) {
+      export cnt.*
+    }
+  }
+
+  object AbstractCounter {
+    abstract case class Counter() {
+      var x: BigInt
+
+      def add(y: BigInt): Unit = {
+        require(y >= 0)
+        x += y
+      }
+
+      def parametricAdd[T](y: BigInt, t: T): Unit = {
+        require(y >= 0)
+        x += y
+      }
+    }
+
+    case class Base(cnt: Counter) {
+      export cnt.*
+    }
+  }
+
+  object AbstractBaseAndCounter {
+    abstract case class Counter() {
+      var x: BigInt
+
+      def add(y: BigInt): Unit = {
+        require(y >= 0)
+        x += y
+      }
+
+      def parametricAdd[T](y: BigInt, t: T): Unit = {
+        require(y >= 0)
+        x += y
+      }
+    }
+
+    abstract case class Base() {
+      val cnt: Counter
+      export cnt.*
+    }
+  }
+}