Address review coments

Author: odersky

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

@@ -545,7 +545,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       def hasConflictingTypeVarsFor(tl: TypeLambda) =
         this.typeVarOfParam(tl.paramRefs(0)) ne c.typeVarOfParam(tl.paramRefs(0))
           // Note: Since TypeVars are allocated in bulk for each type lambda, we only
-          // have to check the first one to find out if some of them are dufferent.
+          // have to check the first one to find out if some of them are different.
       val conflicting = c.domainLambdas.find(tl =>
         this.contains(tl) && hasConflictingTypeVarsFor(tl))
       conflicting match {

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

@@ -145,7 +145,7 @@ class TyperState(private val previous: TyperState /* | Null */) {
   def commit()(implicit ctx: Context): Unit = {
     Stats.record("typerState.commit")
     val targetState = ctx.typerState
-   	if (constraint ne targetState.constraint)
+    if (constraint ne targetState.constraint)
       constr.println(i"committing $this to $targetState, fromConstr = $constraint, toConstr = ${targetState.constraint}")
     assert(isCommittable)
     if (targetState.constraint eq previousConstraint) targetState.constraint = constraint

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -579,7 +579,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case Splice(tree) =>
         keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case tree: Applications.IntegratedTypeArgs =>
-        toText(tree.app) ~ "(with integrated type args)"
+        toText(tree.app) ~ Str("(with integrated type args)").provided(ctx.settings.YprintDebug.value)
       case Thicket(trees) =>
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case _ =>

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

@@ -188,6 +188,8 @@ object Applications {
 
   /** A wrapper indicating that its `app` argument has already integrated the type arguments
    *  of the expected type, provided that type is a (possibly ignored) PolyProto.
+   *  I.e., if the expected type is a PolyProto, then `app` will be a `TypeApply(_, args)` where
+   *  `args` are the type arguments of the expected type.
    */
   class IntegratedTypeArgs(val app: Tree)(implicit @constructorOnly src: SourceFile) extends tpd.Tree {
     override def span = app.span

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

@@ -2233,8 +2233,11 @@ class Typer extends Namer
   }
 
   /** Try to rename `tpt` to a type `T` and typecheck `new T` with given expected type `pt`.
+   *  The operation is called from either `adapt` or `typedApply`. `adapt` gets to call `tryNew`
+   *  for calls `p.C(..)` if there is a value `p.C`. `typedApply` calls `tryNew` as a fallback
+   *  in case typing `p.C` fails since there is no value with path `p.C`. The call from `adapt`
+   *  is more efficient since it re-uses the prefix `p` in typed form.
    */
-
   def tryNew[T >: Untyped <: Type]
     (treesInst: Instance[T])(tree: Trees.Tree[T], pt: Type, fallBack: => Tree)(implicit ctx: Context): Tree = {
 
@@ -2246,6 +2249,8 @@ class Typer extends Namer
         else {
           def recur(tpt: Tree, pt: Type): Tree = pt.revealIgnored match {
             case PolyProto(targs, pt1) if !targs.exists(_.isInstanceOf[NamedArg]) =>
+              // Applications with named arguments cannot be converted, since new expressions
+              // don't accept named arguments
               IntegratedTypeArgs(recur(AppliedTypeTree(tpt, targs), pt1))
             case _ =>
               typed(untpd.Select(untpd.New(untpd.TypedSplice(tpt)), nme.CONSTRUCTOR), pt)