Various fixes to inlining

 Some of them taken by reverting again:

  Remove remaining bits from untyped inliner (reverted from commit 35646ae)

# Conflicts:
#	compiler/src/dotty/tools/dotc/transform/FirstTransform.scala

Author: odersky

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

@@ -665,25 +665,32 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     type MatchRedux = Option[(List[MemberDef], untpd.Tree)]
 
     /** Reduce an inline match
-     *   @param     mtch         the match tree
-     *   @param     scrutinee    the scrutinee expression, assumed to be pure
-     *   @param     scrutType    its fully defined type
-     *   @param     typer        The current inline typer
+     *   @param     mtch          the match tree
+     *   @param     scrutinee     the scrutinee expression, assumed to be pure, or
+     *                            EmptyTree for an implicit match
+     *   @param     scrutType     its fully defined type, or
+     *                            ImplicitScrutineeTypeRef for an implicit match
+     *   @param     typer         The current inline typer
      *   @return    optionally, if match can be reduced to a matching case: A pair of
      *              bindings for all pattern-bound variables and the RHS of the case.
      */
     def reduceInlineMatch(scrutinee: Tree, scrutType: Type, cases: List[untpd.CaseDef], typer: Typer)(implicit ctx: Context): MatchRedux = {
 
-      val isImplicit = scrutType.isRef(defn.ImplicitScrutineeTypeSym)
+      val isImplicit = scrutinee.isEmpty
       val gadtSyms = typer.gadtSyms(scrutType)
 
       /** Try to match pattern `pat` against scrutinee reference `scrut`. If successful add
        *  bindings for variables bound in this pattern to `bindingsBuf`.
        */
       def reducePattern(bindingsBuf: mutable.ListBuffer[MemberDef], scrut: TermRef, pat: Tree)(implicit ctx: Context): Boolean = {
 
-        def newBinding(sym: TermSymbol, rhs: Tree): Unit =
+      	/** Create a binding of a pattern bound variable with matching part of
+      	 *  scrutinee as RHS and type that corresponds to RHS.
+      	 */
+        def newBinding(sym: TermSymbol, rhs: Tree): Unit = {
+          sym.info = rhs.tpe.widenTermRefExpr
           bindingsBuf += ValDef(sym, constToLiteral(rhs))
+        }
 
         def searchImplicit(sym: TermSymbol, tpt: Tree) = {
           val evTyper = new Typer
@@ -771,7 +778,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
                     yield constToLiteral(reduceProjection(ref(scrut).select(accessor).ensureApplied))
                   caseAccessors.length == pats.length && reduceSubPatterns(pats, selectors)
                 }
-                else if (unapp.symbol.isInlineMethod) { // @@@ not sure that's needed / can be supported
+                else if (unapp.symbol.isInlineMethod) { // TODO: Adapt to typed setting
                   val app = untpd.Apply(untpd.TypedSplice(unapp), untpd.ref(scrut))
                   val app1 = typer.typedExpr(app)
                   val args = tupleArgs(app1)
@@ -864,7 +871,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           if (tree.isInline)
             errorTree(tree, em"""cannot reduce inline if
                                 | its condition   ${tree.cond}
-                                | is not a constant value.""")
+                                | is not a constant value""")
           else {
             val if1 = untpd.cpy.If(tree)(cond = untpd.TypedSplice(cond1))
             super.typedIf(if1, pt)
@@ -874,10 +881,11 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree =
       constToLiteral(betaReduce(super.typedApply(tree, pt)))
 
-    override def typedMatchFinish(tree: untpd.Match, sel: Tree, selType: Type, cases: List[untpd.CaseDef], pt: Type)(implicit ctx: Context) =
+    override def typedMatchFinish(tree: untpd.Match, sel: Tree, wideSelType: Type, cases: List[untpd.CaseDef], pt: Type)(implicit ctx: Context) =
       if (!tree.isInline || ctx.owner.isInlineMethod) // don't reduce match of nested inline method yet
-        super.typedMatchFinish(tree, sel, selType, cases, pt)
-      else
+        super.typedMatchFinish(tree, sel, wideSelType, cases, pt)
+      else {
+        val selType = if (sel.isEmpty) wideSelType else sel.tpe
         reduceInlineMatch(sel, selType, cases, this) match {
           case Some((caseBindings, rhs)) =>
             var rhsCtx = ctx.fresh.setNewScope
@@ -892,13 +900,14 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
             val msg =
               if (tree.selector.isEmpty)
                 em"""cannot reduce implicit match with
-                    | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}."""
+                   | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}"""
               else
                 em"""cannot reduce inline match with
                     | scrutinee:  $sel : ${selType}
-                    | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}."""
+                    | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}"""
             errorTree(tree, msg)
         }
+      }
 
     override def newLikeThis: Typer = new InlineTyper
   }
@@ -907,6 +916,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
    *  Inline def bindings that are used only once.
    */
   def dropUnusedDefs(bindings: List[MemberDef], tree: Tree)(implicit ctx: Context): (List[MemberDef], Tree) = {
+    // inlining.println(i"drop unused $bindings%, % in $tree")
     val refCount = newMutableSymbolMap[Int]
     val bindingOfSym = newMutableSymbolMap[MemberDef]
     val dealiased = new java.util.IdentityHashMap[Type, Type]()

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

@@ -75,7 +75,11 @@ object ProtoTypes {
      *  achieved by replacing expected type parameters with wildcards.
      */
     def constrainResult(meth: Symbol, mt: Type, pt: Type)(implicit ctx: Context): Boolean =
-      constrainResult(mt, pt)
+      if (Inliner.isInlineable(meth)) {
+        constrainResult(mt, wildApprox(pt))
+        true
+      }
+      else constrainResult(mt, pt)
   }
 
   object NoViewsAllowed extends Compatibility {

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

@@ -993,8 +993,8 @@ class Typer extends Namer
   }
 
   // Overridden in InlineTyper for inline matches
-  def typedMatchFinish(tree: untpd.Match, sel: Tree, selType: Type, cases: List[untpd.CaseDef], pt: Type)(implicit ctx: Context): Tree = {
-    val cases1 = harmonic(harmonize)(typedCases(cases, selType, pt.notApplied))
+  def typedMatchFinish(tree: untpd.Match, sel: Tree, wideSelType: Type, cases: List[untpd.CaseDef], pt: Type)(implicit ctx: Context): Tree = {
+    val cases1 = harmonic(harmonize)(typedCases(cases, wideSelType, pt.notApplied))
       .asInstanceOf[List[CaseDef]]
     assignType(cpy.Match(tree)(sel, cases1), sel, cases1)
   }
@@ -2473,8 +2473,8 @@ class Typer extends Namer
       else if (Inliner.isInlineable(tree) &&
                !ctx.settings.YnoInline.value &&
                !ctx.isAfterTyper &&
-               !ctx.reporter.hasErrors &&
-               tree.tpe <:< pt) {
+               !ctx.reporter.hasErrors) {
+        tree.tpe <:< wildApprox(pt)
         readaptSimplified(Inliner.inlineCall(tree, pt))
       }
       else if (tree.tpe <:< pt) {