providing minimalistic & controlled kind-polymorphism

Author: mandubian

bincompat-forward.whitelist.conf

@@ -110,6 +110,10 @@ filter {
     {
       matchName="scala.reflect.runtime.Settings.YinductionHeuristics"
       problemName=MissingMethodProblem
+    },
+    {
+      matchName="scala.reflect.runtime.Settings.YkindPolymorphism"
+      problemName=DirectMissingMethodProblem
     }
   ]
 }

src/compiler/scala/reflect/reify/Reifier.scala

@@ -110,7 +110,7 @@ abstract class Reifier extends States
       // needs to be solved some day
       // upd. a new hope: https://groups.google.com/forum/#!topic/scala-internals/TtCTPlj_qcQ
       var importantSymbols = Set[Symbol](
-        NothingClass, AnyClass, SingletonClass, PredefModule, ScalaRunTimeModule, TypeCreatorClass, TreeCreatorClass, MirrorClass,
+        NothingClass, AnyClass, SingletonClass, AnyKindClass, PredefModule, ScalaRunTimeModule, TypeCreatorClass, TreeCreatorClass, MirrorClass,
         ApiUniverseClass, JavaUniverseClass, ReflectRuntimePackage, runDefinitions.ReflectRuntimeCurrentMirror)
       importantSymbols ++= importantSymbols map (_.companionSymbol)
       importantSymbols ++= importantSymbols map (_.moduleClass)

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -30,7 +30,7 @@ trait ScalaSettings extends AbsScalaSettings
   protected def defaultClasspath = sys.env.getOrElse("CLASSPATH", ".")
 
   /** Enabled under -Xexperimental. */
-  protected def experimentalSettings = List[BooleanSetting](YpartialUnification, YinductionHeuristics)
+  protected def experimentalSettings = List[BooleanSetting](YpartialUnification, YinductionHeuristics, YkindPolymorphism)
 
   /** Enabled under -Xfuture. */
   protected def futureSettings = List[BooleanSetting]()
@@ -222,6 +222,7 @@ trait ScalaSettings extends AbsScalaSettings
   val YpartialUnification = BooleanSetting ("-Ypartial-unification", "Enable partial unification in type constructor inference")
   val Yvirtpatmat     = BooleanSetting    ("-Yvirtpatmat", "Enable pattern matcher virtualization")
   val YinductionHeuristics = BooleanSetting ("-Yinduction-heuristics", "Enable induction heuristics in implicit resolution")
+  val YkindPolymorphism = BooleanSetting ("-Ykind-polymorphism", "Enable kind polymorphism")
 
   val exposeEmptyPackage = BooleanSetting ("-Yexpose-empty-package", "Internal only: expose the empty package.").internalOnly()
   val Ydelambdafy        = ChoiceSetting  ("-Ydelambdafy", "strategy", "Strategy used for translating lambdas into JVM code.", List("inline", "method"), "method")

src/compiler/scala/tools/nsc/transform/Erasure.scala

@@ -146,7 +146,7 @@ abstract class Erasure extends InfoTransform
         if (sym == ArrayClass && args.nonEmpty)
           if (unboundedGenericArrayLevel(tp1) == 1) ObjectTpe
           else mapOver(tp1)
-        else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass)
+        else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass || sym == AnyKindClass)
           ObjectTpe
         else if (sym == UnitClass)
           BoxedUnitTpe
@@ -308,7 +308,7 @@ abstract class Erasure extends InfoTransform
             assert(!sym.isAliasType, "Unexpected alias type: " + sym)
             "" + TVAR_TAG + sym.name + ";"
           }
-          else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass)
+          else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass || sym == AnyKindClass)
             jsig(ObjectTpe)
           else if (sym == UnitClass)
             jsig(BoxedUnitTpe)

src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala

@@ -226,7 +226,6 @@ trait ContextErrors {
         }
         assert(!foundType.isErroneous, s"AdaptTypeError - foundType is Erroneous: $foundType")
         assert(!req.isErroneous, s"AdaptTypeError - req is Erroneous: $req")
-
         issueNormalTypeError(callee, withAddendum(callee.pos)(typeErrorMsg(foundType, req)))
         infer.explainTypes(foundType, req)
       }
@@ -695,6 +694,38 @@ trait ContextErrors {
         setError(tree)
       }
 
+      def InferredReturnTypeError(tree: Tree, pt: Type) = {
+        issueNormalTypeError(tree, s"inferred result type ($pt) takes type parameters")
+        setError(tree)
+      }
+
+      def AnyKindTypeError(tree: Tree) = {
+        issueNormalTypeError(tree, s"AnyKind can't be used as a real type")
+        setError(tree)
+      }
+
+      def KindPolymorphicKindArityMismatchError(tree: Tree, pt: Type, targs: List[Type], badTParamArgs: List[(Symbol, Type)], appliedType: Type) = {
+        def typeKindStr(tp: Type): String = {
+          if(tp.typeParams.isEmpty) "*"
+          else tp.typeParams.map(p => symKindStr(p)+"->").mkString("(", "", "*)")
+        }
+
+        def symKindStr(tp: Symbol): String = {
+          if(tp.typeParams.isEmpty) "*"
+          else tp.typeParams.map(p => symKindStr(p)+"->").mkString("(", "", "*)")
+        }
+
+        issueNormalTypeError(tree, {
+          val kindStrs = badTParamArgs.map { case (tparam, targ) =>
+            val kind1 = symKindStr(tparam)
+            val kind2 = typeKindStr(targ)
+            s"${tparam}[$kind1]<=>$targ[$kind2]"
+          }
+          s"[Kind-Polymorphic Error] $tree inferred to type ${pt} with illegally kinded type arguments ${targs.mkString(", ")} applied to type ${appliedType} ${if(kindStrs.nonEmpty) kindStrs.mkString("(kind errors: ", ", ", ")") else ""}"
+        })
+        setError(tree)
+      }
+
       def KindArityMismatchError(tree: Tree, pt: Type) = {
         issueNormalTypeError(tree,
           tree.tpe+" takes "+countElementsAsString(tree.tpe.typeParams.length, "type parameter")+

src/compiler/scala/tools/nsc/typechecker/RefChecks.scala

@@ -466,7 +466,10 @@ abstract class RefChecks extends Transform {
             overrideError("cannot be used here - term macros cannot override abstract methods")
           } else if (other.isTermMacro && !member.isTermMacro) { // (1.10)
             overrideError("cannot be used here - only term macros can override term macros")
-          } else {
+          } else if (other.tpe.isComplete && other.tpe.typeSymbol.isNonBottomSubClass(definitions.AnyKindClass)) {
+            // a AnyKind bounded type can be overriden by a type not bounded by AnyKind (this is the purpose of it)
+          }
+            else {
             checkOverrideTypes()
             checkOverrideDeprecated()
             if (settings.warnNullaryOverride) {

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -170,7 +170,10 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 
           val res =
             if (paramFailed || (paramTp.isErroneous && {paramFailed = true; true})) SearchFailure
-            else inferImplicitFor(paramTp, fun, context, reportAmbiguous = context.reportErrors)
+            else {
+              inferImplicitFor(paramTp, fun, context, reportAmbiguous = context.reportErrors)
+            }
+          
           argResultsBuff += res
 
           if (res.isSuccess) {
@@ -590,7 +593,6 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
      *  4. Give getClass calls a more precise type based on the type of the target of the call.
      */
     protected def stabilize(tree: Tree, pre: Type, mode: Mode, pt: Type): Tree = {
-
       // Side effect time! Don't be an idiot like me and think you
       // can move "val sym = tree.symbol" before this line, because
       // inferExprAlternative side-effects the tree's symbol.
@@ -828,7 +830,6 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
     protected def adapt(tree: Tree, mode: Mode, pt: Type, original: Tree = EmptyTree): Tree = {
       def hasUndets           = context.undetparams.nonEmpty
       def hasUndetsInMonoMode = hasUndets && !mode.inPolyMode
-
       def adaptToImplicitMethod(mt: MethodType): Tree = {
         if (hasUndets) { // (9) -- should revisit dropped condition `hasUndetsInMonoMode`
           // dropped so that type args of implicit method are inferred even if polymorphic expressions are allowed
@@ -965,20 +966,51 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           case _                       => pt == WildcardType
         }
 
+        // should be recursive for checking kind of all subtypes
+        def kpBadKindArityMatches(tparams: List[Symbol], targs: List[Type]): List[(Symbol, Type)] = {
+          tparams.zip(targs).flatMap { case (tparam, targ) =>
+            if (isAnyKind(tparam.tpe)) List()
+            else if (!sameLength(targ.typeParams, tparam.typeParams)) List(tparam -> targ)
+            else kpBadKindArityMatches(tparam.typeParams, targ.typeParams.map(_.tpe))
+          }
+        }
+
         // todo. It would make sense when mode.inFunMode to instead use
         //    tree setType tree.tpe.normalize
         // when typechecking, say, TypeApply(Ident(`some abstract type symbol`), List(...))
         // because otherwise Ident will have its tpe set to a TypeRef, not to a PolyType, and `typedTypeApply` will fail
         // but this needs additional investigation, because it crashes t5228, gadts1 and maybe something else
         if (mode.inFunMode)
           tree
-        else if (properTypeRequired && tree.symbol.typeParams.nonEmpty)  // (7)
+        else if (properTypeRequired && tree.symbol.typeParams.nonEmpty)  // (7) 
           MissingTypeParametersError(tree)
-        else if (kindArityMismatch && !kindArityMismatchOk)  // (7.1) @M: check kind-arity
+        else if (kindArityMismatch && !kindArityMismatchOk) // (7.1) @M: check kind-arity                       
           KindArityMismatchError(tree, pt)
         else tree match { // (6)
           case TypeTree() => tree
-          case _          => TypeTree(tree.tpe) setOriginal tree
+          case _          =>
+            if(settings.YkindPolymorphism) {
+              // we exclude RefinedClasses because in kind-polymorphic cases, it can happen
+              // type Kinder.Aux[H, M, HL0] = Kinder[H]{type M = M; type Args = HL0} gives
+              // isRefinementClass:true tree.tpe.typeSymbol:<refinement of Test.Kinder[H]>
+              // tree.tpe.typeSymbol.typeParams:List()
+              // tree.tpe.typeArgs:List(H, M, HL0)
+              // 
+              if(!tree.tpe.typeSymbol.isRefinementClass && tree.tpe.typeSymbol.typeParams.length == 0 && tree.tpe.typeArgs.length > 0) {
+                KindPolymorphicKindArityMismatchError(original, tree.tpe, tree.tpe.typeArgs, List(), tree.tpe.typeSymbol.tpe)
+              }
+              else if(tree.tpe.typeSymbol.typeParams.length > tree.tpe.typeArgs.length && tree.tpe.typeArgs.length > 0) {
+                // List() to have a nicer error msg
+                KindPolymorphicKindArityMismatchError(original, tree.tpe, tree.tpe.typeArgs, List(), tree.tpe.typeSymbol.tpe)
+              }
+              else {
+                val badKinds = kpBadKindArityMatches(tree.tpe.typeSymbol.typeParams, tree.tpe.typeArgs)
+                if(badKinds.nonEmpty) {
+                  KindPolymorphicKindArityMismatchError(original, tree.tpe, tree.tpe.typeArgs, badKinds, tree.tpe.typeSymbol.tpe)
+                } else TypeTree(tree.tpe) setOriginal tree
+              }
+            }
+            else TypeTree(tree.tpe) setOriginal tree
         }
       }
 
@@ -1103,11 +1135,13 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
                 // all in one fell swoop at the end of typedFunction?
                 val samAttach = inferSamType(tree, pt, mode)
 
+
                 if (samAttach.samTp ne NoType) tree.setType(samAttach.samTp).updateAttachment(samAttach)
                 else {  // (15) implicit view application
                   val coercion =
                     if (context.implicitsEnabled) inferView(tree, tree.tpe, pt)
                     else EmptyTree
+
                   if (coercion ne EmptyTree) {
                     def msg = s"inferred view from ${tree.tpe} to $pt via $coercion: ${coercion.tpe}"
                     if (settings.logImplicitConv) context.echo(tree.pos, msg)
@@ -2270,6 +2304,11 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       val tpt1 = checkNoEscaping.privates(meth, typedType(ddef.tpt))
       checkNonCyclic(ddef, tpt1)
       ddef.tpt.setType(tpt1.tpe)
+
+      // AnyKind shouldn't be usable as a real type
+      if(ddef.tpt.tpe eq definitions.AnyKindClass.tpe) {
+        AnyKindTypeError(ddef.tpt)
+      }
       val typedMods = typedModifiers(ddef.mods)
       var rhs1 =
         if (ddef.name == nme.CONSTRUCTOR && !ddef.symbol.hasStaticFlag) { // need this to make it possible to generate static ctors
@@ -4054,6 +4093,12 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
               checkCheckable(tree, targs.head, scrutineeType, inPattern = false)
             }
             val resultpe = restpe.instantiateTypeParams(tparams, targs)
+
+            // when using YkindPolymorphism, in case resulType has been inferred to a Type Contructor or AnyKind,
+            // let's inform with a nice error
+            if(settings.YkindPolymorphism && (resultpe.resultType.typeParams.nonEmpty || (resultpe.resultType eq definitions.AnyKindClass))) {
+              InferredReturnTypeError(fun, resultpe)
+            } else
             //@M substitution in instantiateParams needs to be careful!
             //@M example: class Foo[a] { def foo[m[x]]: m[a] = error("") } (new Foo[Int]).foo[List] : List[Int]
             //@M    --> first, m[a] gets changed to m[Int], then m gets substituted for List,
@@ -5106,17 +5151,24 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           if (sameLength(tparams, args)) {
             // @M: kind-arity checking is done here and in adapt, full kind-checking is in checkKindBounds (in Infer)
             val args1 = map2Conserve(args, tparams) { (arg, tparam) =>
-              def ptParams = Kind.FromParams(tparam.typeParams)
-
-              // if symbol hasn't been fully loaded, can't check kind-arity except when we're in a pattern,
-              // where we can (we can't take part in F-Bounds) and must (SI-8023)
-              val pt = if (mode.typingPatternOrTypePat) {
-                tparam.initialize; ptParams
+              // if in KindPolymorphism, let's check type is complete, that it is AnyKind and use the inTypeConstructorAllowed mode
+              // in order to avoid ProperTypeRequired and let inference happen later
+              if(settings.YkindPolymorphism && tparam.rawInfo.isComplete && isAnyKind(tparam.tpe)) {
+                typedHigherKindedType(arg, mode)
               }
-              else if (isComplete) ptParams
-              else Kind.Wildcard
+              else {
+                  def ptParams = Kind.FromParams(tparam.typeParams)
+
+                  // if symbol hasn't been fully loaded, can't check kind-arity except when we're in a pattern,
+                  // where we can (we can't take part in F-Bounds) and must (SI-8023)
+                  val pt = if (mode.typingPatternOrTypePat) {
+                    tparam.initialize; ptParams
+                  }
+                  else if (isComplete) ptParams
+                  else Kind.Wildcard
 
-              typedHigherKindedType(arg, mode, pt)
+                  typedHigherKindedType(arg, mode, pt)
+              }
             }
             val argtypes = mapList(args1)(treeTpe)
 
@@ -5297,7 +5349,13 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 
         // @M maybe the well-kindedness check should be done when checking the type arguments conform to the type parameters' bounds?
         val args1 = if (sameLength(args, tparams)) map2Conserve(args, tparams) {
-          (arg, tparam) => typedHigherKindedType(arg, mode, Kind.FromParams(tparam.typeParams))
+          (arg, tparam) =>            
+            // if in KindPolymorphism, let's check type is complete, that it is AnyKind and use the inTypeConstructorAllowed mode
+            // in order to avoid ProperTypeRequired and let inference happen later
+            if(settings.YkindPolymorphism && tparam.rawInfo.isComplete && isAnyKind(tparam.tpe)) {
+              typedHigherKindedType(arg, mode)
+            }
+            else typedHigherKindedType(arg, mode, Kind.FromParams(tparam.typeParams))
         }
         else {
           //@M  this branch is correctly hit for an overloaded polymorphic type. It also has to handle erroneous cases.

src/reflect/scala/reflect/internal/Definitions.scala

@@ -385,6 +385,9 @@ trait Definitions extends api.StandardDefinitions {
     lazy val JavaRepeatedParamClass = specialPolyClass(tpnme.JAVA_REPEATED_PARAM_CLASS_NAME, COVARIANT)(tparam => arrayType(tparam.tpe))
     lazy val RepeatedParamClass     = specialPolyClass(tpnme.REPEATED_PARAM_CLASS_NAME, COVARIANT)(tparam => seqType(tparam.tpe))
 
+    // TODO : requires ABSTRACT | TRAIT | FINAL ????
+    lazy val AnyKindClass   = enterNewClass(ScalaPackageClass, tpnme.AnyKind, AnyTpe :: Nil, ABSTRACT | TRAIT) markAllCompleted
+
     def isByNameParamType(tp: Type)        = tp.typeSymbol == ByNameParamClass
     def isScalaRepeatedParamType(tp: Type) = tp.typeSymbol == RepeatedParamClass
     def isJavaRepeatedParamType(tp: Type)  = tp.typeSymbol == JavaRepeatedParamClass
@@ -756,7 +759,7 @@ trait Definitions extends api.StandardDefinitions {
     def isStable(tp: Type): Boolean = tp match {
       case _: SingletonType                             => true
       case NoPrefix                                     => true
-      case TypeRef(_, NothingClass | SingletonClass, _) => true
+      case TypeRef(_, NothingClass | SingletonClass | AnyKindClass, _) => true
       case TypeRef(_, sym, _) if sym.isAbstractType     => tp.bounds.hi.typeSymbol isSubClass SingletonClass
       case TypeRef(pre, sym, _) if sym.isModuleClass    => isStable(pre)
       case TypeRef(_, _, _) if tp ne tp.dealias         => isStable(tp.dealias)
@@ -1357,7 +1360,8 @@ trait Definitions extends api.StandardDefinitions {
       AnyValClass,
       NullClass,
       NothingClass,
-      SingletonClass
+      SingletonClass,
+      AnyKindClass
     )
     /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
     lazy val syntheticCoreMethods = List(

src/reflect/scala/reflect/internal/Kinds.scala

@@ -151,7 +151,10 @@ trait Kinds {
         log("checkKindBoundsHK under params: "+ underHKParams +" with args "+ withHKArgs)
       }
 
-      if (!sameLength(hkargs, hkparams)) {
+      def isAnyKind = settings.YkindPolymorphism && param.tpe.typeSymbol.isNonBottomSubClass(definitions.AnyKindClass)
+
+      // if using Kind Polymorphism, let it pass now and let inference happen a bit later
+      if (!sameLength(hkargs, hkparams) && !isAnyKind) {
         // Any and Nothing are kind-overloaded
         if (arg == AnyClass || arg == NothingClass) NoKindErrors
         // shortcut: always set error, whether explainTypesOrNot

src/reflect/scala/reflect/internal/StdNames.scala

@@ -256,6 +256,7 @@ trait StdNames {
     final val Singleton: NameType       = "Singleton"
     final val Throwable: NameType       = "Throwable"
     final val unchecked: NameType       = "unchecked"
+    final val AnyKind: NameType         = "AnyKind"
 
     final val api: NameType                 = "api"
     final val Annotation: NameType          = "Annotation"