Add tests

Author: Sporarum

tests/neg/_TypeInterweaving/params.scala

@@ -0,0 +1,5 @@
+class Params{
+    def bar[T](x: T)[T]: String = ??? // error
+    def zoo(x: Int)[T, U](x: U): T = ??? // error
+    def bbb[T <: U](x: U)[U]: U = ??? // error // error
+}

tests/pos/_typeInterweaving/newline.scala

@@ -0,0 +1,9 @@
+class Newline {
+  def multipleLines
+        [T]
+        (x: T)
+        [U]
+        (using (T,U))
+        (y: U)
+        = ???
+}

tests/pos/_typeInterweaving/overload.scala

@@ -1,8 +1,25 @@
 
 class A{
-    def f0[T][U](x: Any) = ???
-    def f0[T][U](x: Int) = ???
+    /*
+    def f0[T](x: Any) = ???
+    def f0[T](x: Int) = ???
+    */
 
-    f0(1)
+    def f1[T][U](x: Any) = ???
+    def f1[T][U](x: Int) = ???
+
+    //f0(1)
+    f1(1)
+    f1("hello")
+
+    case class B[U](x: Int)
+    def b[U](x: Int) = B[U](x)
+
+    def f2[T]: [U] => Int => B[U] = [U] => (x: Int) => b[U](x)
+
+    
+    f2(1)
+    f2[Any](1)
+    f2[Any][Any](1)
 
 }

tests/pos/_typeInterweaving/params.scala

@@ -0,0 +1,6 @@
+class Params{
+    type U
+    def foo[T](x: T)[U >: x.type <: T][L <: List[U]](l: L): L = ???
+    def aaa(x: U): U = ???
+    def bbb[T <: U](x: U)[U]: U = ???
+}

tests/pos/_typeInterweaving/todo.scala

@@ -39,32 +39,28 @@ def foo[T, U][V](x: T): U = ???
 
 //add function call to chainedParams
 
-
-// Que faire de  TypeDcl ::=  id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type]  //TODO: change to {ParamClauses} ?
-
-
-/* Endroits à changer: (toujour creation et application)
+/* Endroits à changer: (toujour creation et application ?)
     function definition     Done
     function application    Already works
-    class definition        In Progress
-        primary constr          In Progress
-        auxiliary constr        In Progress
-    class instantiation     Might already work // see new
-    given definition        Todo
-    given application(?)    Doesn't exist ? or add multiple params to usings ?
-    type declarations       To be determined
+    class definition        Standby
+        primary constr          Standby
+        auxiliary constr        Standby
+    class instantiation     Standby (Might already work // see new)
+    given definition        Todo //yes if given alias, Standby otherwise given name[](using ...)[](using ...) : Classe[Params]
+    given application(?)    Already works ?/standby Doesn't exist ? or add multiple params to usings ? (using name: Class[T]{val x}[U])
+    type declarations       Standby: because no transformation from F[X,Y] <-> F[X][Y] //is [X,Y] =>> F[X][Y] valid ?
     type instantiation      Doesn't exist ?
-    extension definition    Todo   
-    extension application   Todo
+    extension definition    Todo // probably only on right side, since classes do not keep info about params
+    extension application   Todo: tester
  */
 
 
 
 // étapes pour "convaincre"
-// 1) exemples simples, et exemples d'utilité
-// 2) expliquer intuitivement
-// 3) update la doc
-// 4) PR et tout le tralala
+// 1) exemples simples, et exemples d'utilité   TODO
+// 2) expliquer intuitivement                   TODO
+// 3) update la doc                             Done
+// 4) PR et tout le tralala                     TODO
 
 
 //potentiellement cette feature en experimental
@@ -77,20 +73,85 @@ val f = foo //should work and doesn't preserve type params yet
 
 
 //new:
-// mettre de coté la partie sur les classes
-// fork le repo de la doc est faire changements appropriés
+// mettre de coté la partie sur les classes: Done
+// fork le repo de la doc est faire changements appropriés: Done: https://github.com/scala/scala/pull/9792
 // check overloading resolution
-// Applications.scala resolveMapped
+// Applications.scala resolveMapped //What to do here?
 //                      methType
 // ProtoTypes.scala
 
-// check ne passer aucun arguments à une fonction
-// voir fichier overload dans pos/interweaving_
-// voir methType
+// check ne passer aucun arguments à une fonction // Je me rappelle pas ce que c'était ...
+// voir fichier overload dans pos/interweaving_   // Done
+// voir methType                                  // Done ?
 // check occurances de PolyType et PolyProto pour être sûr que ça fonctionne bien avec les [T][U]
+//    PolyType:  Done in Application.scala
+//    PolyProto: Done in Application.scala
 // testCompilation
+//    Pas eu le temps, mais la PR a lancer des tests, donc 5 qui ont ratés dans une phase
 
+// check def foo[T][T]
+//
+// is def foo[T](using T)(x: Int) valid ?
+/*
+ * check: done see newline.scala
+ * def foo
+ *  [T]
+ *  (x: T)
+ *  [U]
+ * 
+ * and similar
+ * 
+*/
 
 
 // should we allow fun[L <: List[T]][T] as alias for something like fun[F[_] <: List[]][T][L <: F[T]]
-// I'm not sure it's useful
+// I'm not sure it's useful
+
+
+
+// dans docu check "method type" et "poly(morphic) type/method" pour voir si suppositions fausses
+// 
+
+// tryApply:
+//   si f pas fonction, essaie f.apply(...)
+
+
+
+// next:
+// Relire toute docu: Done
+// voir eta expension dans la doc, pour voir comment changer pour polymorphique, ajouter texte qui explique que passe parfois param de type si besoin
+// mettre un peu au propre texte PR -> trouver exemples
+// essayer given def: Paused
+
+
+/**
+ * A few comments:
+    Should handle and test for extension definitions as well.
+    Should test of overriding and signature check and proper report when signature does not match.
+    I suggest opening a thread on https://contributors.scala-lang.org/ to discuss this language change. 
+ * 
+ * 
+ * 
+ * 
+ */
+
+
+// type Z = X =>> F[X]
+// def name: [X] => (X, X) => (U)
+
+
+// def foo[T](x: T): T
+// val bar = foo
+
+
+// check overload: (should fail)
+// def foo(x: Int)(y: String)
+// def foo(x: Int)[T](y: String)
+// def foo[T](x: Int)(y: String)
+
+
+
+// next
+// adaptations faitent dans Typer.scala adapt (regarder la fin ou il y a le "vrai" body de la fonction)
+// pour rajouter le cas valId3 qui typecheck (les autres cas ce sera pour après)
+// https://github.com/lampepfl/dotty/pull/4672