Merge pull request #9 from fmonniot/fix-issue-4

Add support for by-name parameters

Author: fmonniot

core/src/main/scala/eu/monniot/scala3mock/macros/MockImpl.scala

@@ -70,18 +70,28 @@ private class MockImpl[T](ctx: Expr[MockContext], debug: Boolean)(using
         )
 
       case DefDef(name, params, returnTpt, _) =>
-        val args = params.flatMap {
-          case TermParamClause(vals) => vals
-          case TypeParamClause(_)    => List.empty
-        }
-
-        val types = args.map(_.tpt.tpe) :+ returnTpt.tpe
+        val args = params
+          .flatMap {
+            case TermParamClause(vals) => vals.map(_.tpt.tpe)
+            case TypeParamClause(_)    => List.empty
+          }
+          .map {
+            case ByNameType(inner) =>
+              // By-name types are interesting because internally they have a type-representation,
+              // but that is not something that we can actually do in "official" Scala. Not removing
+              // this node means that the by-name value isn't being evaluated and so when we compare
+              // the expectation (an evaluated value) vs the actual value (a lambda, as it's not evaluated)
+              // we ends up with some mismatch. By removing this type component, we are effectively saying to
+              // the compiler that we want to evaluate the argument before passing it to our MockFunction
+              inner
+            case otherwise => otherwise
+          }
 
         (
           Symbol.requiredClass(
             s"eu.monniot.scala3mock.functions.MockFunction${args.length}"
           ),
-          types
+          args :+ returnTpt.tpe
         )
 
       case tree =>
@@ -361,6 +371,8 @@ private class MockImpl[T](ctx: Expr[MockContext], debug: Boolean)(using
                 None // We can ignore the rest as we are only looking at arguments here
             }
 
+            // Build the Map access. In scala that would look something like
+            // MockClassName.this.mocks.asInstanceOf[MockFunctionX].apply(x)
             val mockFnType =
               AppliedType(mockFunctionClsSym.typeRef, mockFnTypeArgs)
 

core/src/main/scala/eu/monniot/scala3mock/macros/WhenImpl.scala

@@ -20,10 +20,13 @@ private[scala3mock] object WhenImpl:
       val mf = ${createMockFunction(f)}.asInstanceOf[MockFunction1[T1, R]]
 
       // used to debug what it is being infered
-      //println(s"selected MockFunction1 = $mf")
-      //println(s"T1 = " + ${Expr(Type.show[T1])})
-      //println(s"R =  " + ${Expr(Type.show[R])})
-
+      /*
+      println(s"""|selected MockFunction1 = $mf
+                  |T1 = ${${Expr(Type.show[T1])}}
+                  |T1.repr = ${${Expr(TypeRepr.of[T1].toString())}}
+                  |R = ${${Expr(Type.show[R])}}
+                  |""".stripMargin)
+      */
       mf
     }
 
@@ -127,7 +130,7 @@ private[scala3mock] object WhenImpl:
                 // If there are no overload, let's use the method name as the mock key. Otherwise
                 // append the index of the overload. Using the same sort here and in the mock
                 // declaration is important for the indices to match.
-                if overload.length == 1 then name
+                if overload.length < 2 then name
                 else {
                   val idx = overload.indexWhere(_.signature == signature)
 

core/src/test/scala/eu/monniot/scala3mock/mock/MockSuite.scala

@@ -77,10 +77,14 @@ class MockSuite extends munit.FunSuite with MockFunctions {
       when(m.repeatedParam _).expects(0, Seq.empty).returning("hello")
       assertEquals(m.repeatedParam(0), "hello")
 
-      // TODO Not supported yet
-      // https://github.com/fmonniot/scala3mock/issues/4
-      // when(m.byNameParam).expects(3).returns("ok")
-      // assertEquals(m.byNameParam(3), "ok")
+      // Partially supported. Issue with type inference still. See https://github.com/fmonniot/scala3mock/issues/4
+      // Interestingly enough here if we do not force the types, the compiler will happily
+      // infer a type `((=> Int) => String)` which doesn't matches any of our `when` declarations.
+      // This can also be fixed by having the when/WhenImpl macros takes a by-name parameter. That
+      // second solution isn't very practical for 3+ matchers as it would explode the number of overload
+      // required to match all possible cases.
+      when[Int, String](m.byNameParam).expects(3).returns("ok")
+      assertEquals(m.byNameParam(3), "ok")
 
       // implicit parameters
       given y: Double = 1.23

docs/user-guide/installation.md

@@ -21,4 +21,4 @@ title: Installation
 - No cross compilation with Scala2
 - Support for ScalaTest's `path.FunSpec` removed (help welcome)
 - Support for inner types ([help welcome](https://github.com/fmonniot/scala3mock/issues/3))
-- Support for by-name parameters ([help welcome](https://github.com/fmonniot/scala3mock/issues/4))
+- By-name parameters ([help welcome](https://github.com/fmonniot/scala3mock/issues/4)) currently have issues with type inference, but work fine when fully specifiying types when defining the expectations (eg. `when[String, Int](mock.function).expects("val").returns(1)`)