WIP

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -671,7 +671,8 @@ object Types {
         val rinfo = tp.refinedInfo
         if (name.isTypeName && !pinfo.isInstanceOf[ClassInfo]) { // simplified case that runs more efficiently
           val jointInfo =
-            if (ctx.base.pendingMemberSearches.contains(name)) pinfo safe_& rinfo
+            if rinfo.isInstanceOf[TypeAlias] then rinfo
+            else if (ctx.base.pendingMemberSearches.contains(name)) pinfo safe_& rinfo
             else pinfo recoverable_& rinfo
           pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
         }

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -340,6 +340,34 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           else
             Checking.checkAppliedType(tree)
           super.transform(tree)
+        case tree: RefinedTypeTree =>
+          //println(i"checking $tree: ${tree.tpe}")
+          def checkRefinements(tp: Type): Unit = tp match
+            case RefinedType(parent, name, info) =>
+              info match
+                case info: TypeAlias =>
+                  val mbr = parent.member(name)
+                  mbr.info match
+                    case bounds: TypeBounds if !bounds.contains(info) =>
+                      //println(i"falling back to checking F-bounded ${tree.tpe}")
+                      val site = tree.tpe.narrow
+                      val narrowMbr = mbr.asSeenFrom(site)
+                      val owner = mbr.symbol.maybeOwner
+                      val narrowInfo = info.asSeenFrom(site, owner)
+                      val ok = narrowMbr.info match
+                        case bounds: TypeBounds => bounds.contains(narrowInfo)
+                        case _ => false
+                      //println(i"fall back ${narrowMbr.info} $narrowInfo")
+                      if !ok then
+                        report.error(
+                          em"""type alias     type $name$info
+                              |out of bounds: $bounds / ${bounds.toString}""", tree.sourcePos)
+                    case _ =>
+                case _ =>
+              checkRefinements(parent)
+            case _ =>
+          checkRefinements(tree.tpe)
+          super.transform(tree)
         case SingletonTypeTree(ref) =>
           Checking.checkRealizable(ref.tpe, ref.posd)
           super.transform(tree)

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -123,6 +123,18 @@ object Checking {
     withMode(Mode.AllowLambdaWildcardApply)(checkValidIfApply)
   }
 
+  /** Check refined type for well-formedness. This means
+   *   - all arguments are within their corresponding bounds
+   *   - if type is a higher-kinded application with wildcard arguments,
+   *     check that it or one of its supertypes can be reduced to a normal application.
+   *     Unreducible applications correspond to general existentials, and we
+   *     cannot handle those.
+   *  @param tree The applied type tree to check
+   *  @param tpt  If `tree` is synthesized from a type in a TypeTree,
+   *              the original TypeTree, or EmptyTree otherwise.
+  def checkRefinedType(tp: RefinedType)
+   */
+
   /** Check all applied type trees in inferred type `tpt` for well-formedness */
   def checkAppliedTypesIn(tpt: TypeTree)(using Context): Unit =
     val checker = new TypeTraverser: