Centralize methods for local context creation

Collect them all in NamerContextOps. Previously some were also in Typer and
in Context itself.

Author: odersky

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

@@ -92,6 +92,29 @@ trait NamerContextOps { this: Context =>
       .dropWhile(_.owner == sym)
       .next()
 
+  /** A fresh local context with given tree and owner.
+   *  Owner might not exist (can happen for self valdefs), in which case
+   *  no owner is set in result context
+   */
+  def localContext(tree: untpd.Tree, owner: Symbol): FreshContext = {
+    val freshCtx = fresh.setTree(tree)
+    if (owner.exists) freshCtx.setOwner(owner) else freshCtx
+  }
+
+  /** A new context for the interior of a class */
+  def inClassContext(selfInfo: DotClass /* Should be Type | Symbol*/): Context = {
+    val localCtx: Context = ctx.fresh.setNewScope
+    selfInfo match {
+      case sym: Symbol if sym.exists && sym.name != nme.WILDCARD => localCtx.scope.openForMutations.enter(sym)
+      case _ =>
+    }
+    localCtx
+  }
+
+  def packageContext(tree: untpd.PackageDef, pkg: Symbol): Context =
+    if (pkg is Package) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree)
+    else ctx
+
   /** The given type, unless `sym` is a constructor, in which case the
    *  type of the constructed instance is returned
    */
@@ -405,17 +428,6 @@ class Namer { typer: Typer =>
     case _ => tree
   }
 
-  /** A new context for the interior of a class */
-  def inClassContext(selfInfo: DotClass /* Should be Type | Symbol*/)(implicit ctx: Context): Context = {
-    val localCtx: Context = ctx.fresh.setNewScope
-    selfInfo match {
-      case sym: Symbol if sym.exists && sym.name != nme.WILDCARD =>
-        localCtx.scope.openForMutations.enter(sym)
-      case _ =>
-    }
-    localCtx
-  }
-
   /** For all class definitions `stat` in `xstats`: If the companion class if
     * not also defined in `xstats`, invalidate it by setting its info to
     * NoType.
@@ -953,7 +965,7 @@ class Namer { typer: Typer =>
       index(constr)
       annotate(constr :: params)
 
-      indexAndAnnotate(rest)(inClassContext(selfInfo))
+      indexAndAnnotate(rest)(ctx.inClassContext(selfInfo))
       symbolOfTree(constr).ensureCompleted()
 
       val parentTypes = ensureFirstIsClass(parents.map(checkedParentType(_)), cls.pos)

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

@@ -1496,12 +1496,12 @@ class Typer extends Namer
       cdef.withType(UnspecifiedErrorType)
     } else {
       val dummy = localDummy(cls, impl)
-      val body1 = typedStats(impl.body, dummy)(inClassContext(self1.symbol))
+      val body1 = typedStats(impl.body, dummy)(ctx.inClassContext(self1.symbol))
       if (!ctx.isAfterTyper)
         cls.setNoInitsFlags((NoInitsInterface /: body1) ((fs, stat) => fs & defKind(stat)))
 
       // Expand comments and type usecases
-      cookComments(body1.map(_.symbol), self1.symbol)(localContext(cdef, cls).setNewScope)
+      cookComments(body1.map(_.symbol), self1.symbol)(ctx.localContext(cdef, cls).setNewScope)
 
       checkNoDoubleDefs(cls)
       val impl1 = cpy.Template(impl)(constr1, parents1, self1, body1)
@@ -1604,15 +1604,12 @@ class Typer extends Namer
     // Package will not exist if a duplicate type has already been entered, see
     // `tests/neg/1708.scala`, else branch's error message should be supressed
     if (pkg.exists) {
-      val packageContext =
-        if (pkg is Package) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree)
-        else {
-          ctx.error(PackageNameAlreadyDefined(pkg), tree.pos)
-          ctx
-        }
-      val stats1 = typedStats(tree.stats, pkg.moduleClass)(packageContext)
+      if (!pkg.is(Package)) ctx.error(PackageNameAlreadyDefined(pkg), tree.pos)
+      val packageCtx = ctx.packageContext(tree, pkg)
+      val stats1 = typedStats(tree.stats, pkg.moduleClass)(packageCtx)
       cpy.PackageDef(tree)(pid1.asInstanceOf[RefTree], stats1) withType pkg.termRef
-    } else errorTree(tree, i"package ${tree.pid.name} does not exist")
+    }
+    else errorTree(tree, i"package ${tree.pid.name} does not exist")
   }
 
   def typedAnnotated(tree: untpd.Annotated, pt: Type)(implicit ctx: Context): Tree = track("typedAnnotated") {
@@ -1708,15 +1705,6 @@ class Typer extends Namer
       NoSymbol
   }
 
-  /** A fresh local context with given tree and owner.
-   *  Owner might not exist (can happen for self valdefs), in which case
-   *  no owner is set in result context
-   */
-  protected def localContext(tree: untpd.Tree, owner: Symbol)(implicit ctx: Context): FreshContext = {
-    val freshCtx = ctx.fresh.setTree(tree)
-    if (owner.exists) freshCtx.setOwner(owner) else freshCtx
-  }
-
   protected def localTyper(sym: Symbol): Typer = nestedTyper.remove(sym).get
 
   def typedUnadapted(initTree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = {
@@ -1734,15 +1722,15 @@ class Typer extends Namer
             case tree: untpd.Bind => typedBind(tree, pt)
             case tree: untpd.ValDef =>
               if (tree.isEmpty) tpd.EmptyValDef
-              else typedValDef(tree, sym)(localContext(tree, sym).setNewScope)
+              else typedValDef(tree, sym)(ctx.localContext(tree, sym).setNewScope)
             case tree: untpd.DefDef =>
               val typer1 = localTyper(sym)
-              typer1.typedDefDef(tree, sym)(localContext(tree, sym).setTyper(typer1))
+              typer1.typedDefDef(tree, sym)(ctx.localContext(tree, sym).setTyper(typer1))
             case tree: untpd.TypeDef =>
               if (tree.isClassDef)
-                typedClassDef(tree, sym.asClass)(localContext(tree, sym).setMode(ctx.mode &~ Mode.InSuperCall))
+                typedClassDef(tree, sym.asClass)(ctx.localContext(tree, sym).setMode(ctx.mode &~ Mode.InSuperCall))
               else
-                typedTypeDef(tree, sym)(localContext(tree, sym).setNewScope)
+                typedTypeDef(tree, sym)(ctx.localContext(tree, sym).setNewScope)
             case _ => typedUnadapted(desugar(tree), pt)
           }
         }
@@ -1776,7 +1764,7 @@ class Typer extends Namer
           case tree: untpd.OrTypeTree => typedOrTypeTree(tree)
           case tree: untpd.RefinedTypeTree => typedRefinedTypeTree(tree)
           case tree: untpd.AppliedTypeTree => typedAppliedTypeTree(tree)
-          case tree: untpd.LambdaTypeTree => typedLambdaTypeTree(tree)(localContext(tree, NoSymbol).setNewScope)
+          case tree: untpd.LambdaTypeTree => typedLambdaTypeTree(tree)(ctx.localContext(tree, NoSymbol).setNewScope)
           case tree: untpd.ByNameTypeTree => typedByNameTypeTree(tree)
           case tree: untpd.TypeBoundsTree => typedTypeBoundsTree(tree, pt)
           case tree: untpd.Alternative => typedAlternative(tree, pt)