Allow toplevel definitions

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1022,6 +1022,36 @@ object desugar {
  else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
  }
 
+ /** Group all definitions that can't be at the toplebel in
+ * an object named `<source>#object` where `<source>` is the name of the source file.
+ * Definitions that can't be at the toplevel are:
+ *
+ * - all pattern, value and method definitions
+ * - non-class type definitions
+ * - implicit classes and objects
+ * - companion objects of opaque types
+ */
+ def packageDef(pdef: PackageDef)(implicit ctx: Context): PackageDef = {
+ val opaqueNames = pdef.stats.collect {
+ case stat: TypeDef if stat.mods.is(Opaque) => stat.name
+ }
+ def needsObject(stat: Tree) = stat match {
+ case _: ValDef | _: PatDef | _: DefDef => true
+ case stat: ModuleDef =>
+ stat.mods.is(Implicit) || opaqueNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
+ case stat: TypeDef => !stat.isClassDef || stat.mods.is(Implicit)
+ case _ => false
+ }
+ val (nestedStats, topStats) = pdef.stats.partition(needsObject)
+ if (nestedStats.isEmpty) pdef
+ else {
+ val sourceName = ctx.source.file.name.takeWhile(_ != '.')
+ val groupName = (sourceName ++ str.TOPLEVEL_SUFFIX).toTermName
+ val grouped = ModuleDef(groupName, Template(emptyConstructor, Nil, Nil, EmptyValDef, nestedStats))
+ cpy.PackageDef(pdef)(pdef.pid, topStats :+ grouped)
+ }
+ }
+
  /** Make closure corresponding to function.
  * params => body
  * ==>
@@ -1086,8 +1116,8 @@ object desugar {
  }
 
  def makeContextualFunction(formals: List[Type], body: Tree)(implicit ctx: Context): Tree = {
- val params = makeImplicitParameters(formals.map(TypeTree), Contextual)
- new FunctionWithMods(params, body, Modifiers(Implicit | Contextual))
+ val params = makeImplicitParameters(formals.map(TypeTree), Given)
+ new FunctionWithMods(params, body, Modifiers(Implicit | Given))
  }
 
  /** Add annotation to tree:

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -331,13 +331,13 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
 
  /** Is `tree` an implicit function or closure, possibly nested in a block? */
  def isContextualClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
- case tree: FunctionWithMods => tree.mods.is(Contextual)
- case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Contextual)
+ case tree: FunctionWithMods => tree.mods.is(Given)
+ case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Given)
  case Closure(_, meth, _) => true
  case Block(Nil, expr) => isContextualClosure(expr)
  case Block(DefDef(nme.ANON_FUN, _, params :: _, _, _) :: Nil, cl: Closure) =>
  params match {
- case param :: _ => param.mods.is(Contextual)
+ case param :: _ => param.mods.is(Given)
  case Nil => cl.tpt.eq(untpd.ContextualEmptyTree) || defn.isImplicitFunctionType(cl.tpt.typeOpt)
  }
  case _ => false

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -234,7 +234,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
  def valueParam(name: TermName, origInfo: Type): TermSymbol = {
  val maybeImplicit =
- if (tp.isContextual) Implicit | Contextual
+ if (tp.isContextual) Implicit | Given
  else if (tp.isImplicitMethod) Implicit
  else EmptyFlags
  val maybeErased = if (tp.isErasedMethod) Erased else EmptyFlags

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -132,6 +132,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
  case class Implicit()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.ImplicitCommon)
 
+ case class Given()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.ImplicitCommon | Flags.Given)
+
  case class Erased()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Erased)
 
  case class Final()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Final)

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

@@ -100,7 +100,7 @@ class Definitions {
  * ImplicitFunctionN traits follow this template:
  *
  * trait ImplicitFunctionN[T0,...,T{N-1}, R] extends Object {
- * def apply with ($x0: T0, ..., $x{N_1}: T{N-1}): R
+ * def apply given ($x0: T0, ..., $x{N_1}: T{N-1}): R
  * }
  *
  * ErasedFunctionN traits follow this template:
@@ -112,7 +112,7 @@ class Definitions {
  * ErasedImplicitFunctionN traits follow this template:
  *
  * trait ErasedImplicitFunctionN[T0,...,T{N-1}, R] extends Object {
- * def apply with (erased $x0: T0, ..., $x{N_1}: T{N-1}): R
+ * def apply given (erased $x0: T0, ..., $x{N_1}: T{N-1}): R
  * }
  *
  * ErasedFunctionN and ErasedImplicitFunctionN erase to Function0.

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

@@ -412,7 +412,7 @@ object Denotations {
  def precedes(sym1: Symbol, sym2: Symbol) = {
  def precedesIn(bcs: List[ClassSymbol]): Boolean = bcs match {
  case bc :: bcs1 => (sym1 eq bc) || !(sym2 eq bc) && precedesIn(bcs1)
- case Nil => true
+ case Nil => false
  }
  (sym1 ne sym2) &&
  (sym1.derivesFrom(sym2) ||
@@ -1183,7 +1183,7 @@ object Denotations {
  */
  def isDoubleDef(sym1: Symbol, sym2: Symbol)(implicit ctx: Context): Boolean =
  (sym1.exists && sym2.exists &&
- (sym1 ne sym2) && (sym1.owner eq sym2.owner) &&
+ (sym1 `ne` sym2) && (sym1.effectiveOwner `eq` sym2.effectiveOwner) &&
  !sym1.is(Bridge) && !sym2.is(Bridge))
 
  def doubleDefError(denot1: Denotation, denot2: Denotation, pre: Type = NoPrefix)(implicit ctx: Context): Nothing = {
@@ -1193,7 +1193,7 @@ object Denotations {
  throw new MergeError(sym1, sym2, sym1.info, sym2.info, pre) {
  override def addendum(implicit ctx: Context) =
  i"""
- |they are both defined in ${sym1.owner} but have matching signatures
+ |they are both defined in ${sym1.effectiveOwner} but have matching signatures
  | ${denot1.info} and
  | ${denot2.info}${super.addendum}"""
  }
@@ -1227,7 +1227,7 @@ object Denotations {
  final case class DenotUnion(denot1: PreDenotation, denot2: PreDenotation) extends MultiPreDenotation {
  def exists: Boolean = true
  def toDenot(pre: Type)(implicit ctx: Context): Denotation =
- (denot1 toDenot pre) & (denot2 toDenot pre, pre)
+ denot1.toDenot(pre).&(denot2.toDenot(pre), pre)
  def containsSym(sym: Symbol): Boolean =
  (denot1 containsSym sym) || (denot2 containsSym sym)
  type AsSeenFromResult = PreDenotation

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

@@ -347,8 +347,8 @@ object Flags {
  /** An extension method */
  final val Extension = termFlag(28, "<extension>")
 
- /** A contextual (with) parameter */
- final val Contextual = commonFlag(29, "<contextual>")
+ /** An inferable (`given`) parameter */
+ final val Given = commonFlag(29, "given")
 
  /** Symbol is defined by a Java class */
  final val JavaDefined: FlagSet = commonFlag(30, "<java>")

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

@@ -87,6 +87,16 @@ object NameOps {
  false
  }
 
+ /** is this the name of an object enclosing packagel-level definitions? */
+ def isPackageObjectName: Boolean = name match {
+ case name: TermName => name == nme.PACKAGE || name.endsWith(str.TOPLEVEL_SUFFIX)
+ case name: TypeName =>
+ name.toTermName match {
+ case ModuleClassName(original) => original.isPackageObjectName
+ case _ => false
+ }
+ }
+
  /** Convert this module name to corresponding module class name */
  def moduleClassName: TypeName = name.derived(ModuleClassName).toTypeName
 

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

@@ -20,6 +20,7 @@ object StdNames {
  final val INITIALIZER_PREFIX = "initial$"
  final val AVOID_CLASH_SUFFIX = "$_avoid_name_clash_$"
  final val MODULE_SUFFIX = "$"
+ final val TOPLEVEL_SUFFIX = "$package"
  final val NAME_JOIN = "$"
  final val DEFAULT_GETTER = "$default$"
  final val LOCALDUMMY_PREFIX = "<local " // owner of local blocks
@@ -483,7 +484,6 @@ object StdNames {
  val notifyAll_ : N = "notifyAll"
  val notify_ : N = "notify"
  val null_ : N = "null"
- val of: N = "of"
  val ofDim: N = "ofDim"
  val opaque: N = "opaque"
  val ordinal: N = "ordinal"

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

@@ -18,6 +18,7 @@ import config.Config
 import reporting.diagnostic.Message
 import reporting.diagnostic.messages.BadSymbolicReference
 import reporting.trace
+import collection.mutable
 
 import scala.annotation.internal.sharable
 
@@ -518,12 +519,8 @@ object SymDenotations {
  name == tpnme.REFINE_CLASS
 
  /** Is this symbol a package object or its module class? */
- def isPackageObject(implicit ctx: Context): Boolean = {
- val nameMatches =
- if (isType) name == tpnme.PACKAGE.moduleClassName
- else name == nme.PACKAGE
- nameMatches && (owner is Package) && (this is Module)
- }
+ def isPackageObject(implicit ctx: Context): Boolean =
+ name.isPackageObjectName && (owner is Package) && (this is Module)
 
  /** Is this symbol an abstract type? */
  final def isAbstractType(implicit ctx: Context): Boolean = this is DeferredType
@@ -758,9 +755,7 @@ object SymDenotations {
  ( !(this is Local)
  || (owner is ImplClass) // allow private local accesses to impl class members
  || isCorrectThisType(pre)
- ) &&
- (!(this.is(Private) && owner.is(Package)) ||
- owner == ctx.owner.enclosingPackageClass)
+ )
  || (this is Protected) &&
  ( superAccess
  || pre.isInstanceOf[ThisType]
@@ -1680,9 +1675,9 @@ object SymDenotations {
  val denots1 = collect(denots, ps)
  p.classSymbol.denot match {
  case parentd: ClassDenotation =>
- denots1 union
+ denots1.union(
  parentd.nonPrivateMembersNamed(name)
- .mapInherited(ownDenots, denots1, thisType)
+  .mapInherited(ownDenots, denots1, thisType))
  case _ =>
  denots1
  }
@@ -1940,17 +1935,39 @@ object SymDenotations {
  initPrivateWithin: Symbol)
  extends ClassDenotation(symbol, ownerIfExists, name, initFlags, initInfo, initPrivateWithin) {
 
- private[this] var packageObjCache: SymDenotation = _
- private[this] var packageObjRunId: RunId = NoRunId
-
- /** The package object in this class, of one exists */
- def packageObj(implicit ctx: Context): SymDenotation = {
- if (packageObjRunId != ctx.runId) {
- packageObjRunId = ctx.runId
- packageObjCache = NoDenotation // break cycle in case we are looking for package object itself
- packageObjCache = findMember(nme.PACKAGE, thisType, EmptyFlagConjunction, EmptyFlags).asSymDenotation
+ private[this] var packageObjsCache: List[ClassDenotation] = _
+ private[this] var packageObjsRunId: RunId = NoRunId
+
+ /** The package objects in this class */
+ def packageObjs(implicit ctx: Context): List[ClassDenotation] = {
+ if (packageObjsRunId != ctx.runId) {
+ packageObjsRunId = ctx.runId
+ packageObjsCache = Nil // break cycle in case we are looking for package object itself
+ packageObjsCache = {
+ val pkgObjBuf = new mutable.ListBuffer[ClassDenotation]
+ for (sym <- info.decls) { // don't use filter, since that loads classes with `$`s in their name
+ val denot = sym.lastKnownDenotation // don't use `sym.denot`, as this brings forward classes too early
+ if (denot.isType && denot.name.isPackageObjectName)
+ pkgObjBuf += sym.asClass.classDenot
+ }
+ pkgObjBuf.toList
+ }
  }
- packageObjCache
+ packageObjsCache
+ }
+
+ /** The package object (as a term symbol) in this package that might contain
+ * `sym` as a member.
+ */
+ def packageObjFor(sym: Symbol)(implicit ctx: Context): Symbol = {
+ val owner = sym.maybeOwner
+ if (owner.is(Package)) NoSymbol
+ else if (owner.isPackageObject) owner.sourceModule
+ else // owner could be class inherited by package object (until package object inheritance is removed)
+ packageObjs.find(_.name == packageTypeName) match {
+ case Some(pobj) => pobj.sourceModule
+ case _ => NoSymbol
+ }
  }
 
  /** Looks in both the package object and the package for members. The precise algorithm
@@ -1966,28 +1983,33 @@ object SymDenotations {
  * object that hides a class or object in the scala package of the same name, because
  * the behavior would then be unintuitive for such members.
  */
- override def computeNPMembersNamed(name: Name)(implicit ctx: Context): PreDenotation =
- packageObj.moduleClass.denot match {
- case pcls: ClassDenotation if !pcls.isCompleting =>
- if (symbol eq defn.ScalaPackageClass) {
- val denots = super.computeNPMembersNamed(name)
- if (denots.exists) denots else pcls.computeNPMembersNamed(name)
- }
- else {
- val denots = pcls.computeNPMembersNamed(name)
- if (denots.exists) denots else super.computeNPMembersNamed(name)
- }
- case _ =>
- super.computeNPMembersNamed(name)
+ override def computeNPMembersNamed(name: Name)(implicit ctx: Context): PreDenotation = {
+ def recur(pobjs: List[ClassDenotation], acc: PreDenotation): PreDenotation = pobjs match {
+ case pcls :: pobjs1 =>
+ if (pcls.isCompleting) recur(pobjs1, acc)
+ else recur(pobjs1, acc.union(pcls.computeNPMembersNamed(name)))
+ case nil =>
+ val directMembers = super.computeNPMembersNamed(name)
+ if (acc.exists) acc.union(directMembers.filterWithPredicate(!_.symbol.isAbsent))
+ else directMembers
  }
+ if (symbol `eq` defn.ScalaPackageClass) {
+ val denots = super.computeNPMembersNamed(name)
+ if (denots.exists) denots
+ else recur(packageObjs, NoDenotation)
+ }
+ else recur(packageObjs, NoDenotation)
+ }
 
  /** The union of the member names of the package and the package object */
  override def memberNames(keepOnly: NameFilter)(implicit onBehalf: MemberNames, ctx: Context): Set[Name] = {
- val ownNames = super.memberNames(keepOnly)
- packageObj.moduleClass.denot match {
- case pcls: ClassDenotation => ownNames union pcls.memberNames(keepOnly)
- case _ => ownNames
+ def recur(pobjs: List[ClassDenotation], acc: Set[Name]): Set[Name] = pobjs match {
+ case pcls :: pobjs1 =>
+ recur(pobjs1, acc.union(pcls.memberNames(keepOnly)))
+ case nil =>
+ acc
  }
+ recur(packageObjs, super.memberNames(keepOnly))
  }
 
  /** If another symbol with the same name is entered, unlink it,
@@ -1999,7 +2021,7 @@ object SymDenotations {
  if (entry != null) {
  if (entry.sym == sym) return false
  mscope.unlink(entry)
- if (sym.name == nme.PACKAGE) packageObjRunId = NoRunId
+ if (sym.name.isPackageObjectName) packageObjsRunId = NoRunId
  }
  true
  }
@@ -2349,5 +2371,7 @@ object SymDenotations {
  def baseClasses: List[ClassSymbol] = classes
  }
 
+ private val packageTypeName = ModuleClassName(nme.PACKAGE).toTypeName
+
  @sharable private[this] var indent = 0 // for completions printing
 }

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

@@ -8,6 +8,7 @@ import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
 import config.Config
 import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, Names._
 import NameOps._
+import StdNames.str
 import Decorators.{PreNamedString, StringInterpolators}
 import classfile.ClassfileParser
 import util.Stats
@@ -236,11 +237,18 @@ object SymbolLoaders {
 
  private[core] val currentDecls: MutableScope = new PackageScope()
 
- def isFlatName(name: SimpleName): Boolean = name.lastIndexOf('$', name.length - 2) >= 0
+ private def isFlatName(name: SimpleName): Boolean = {
+ val idx = name.lastIndexOf('$', name.length - 2)
+ idx >= 0 &&
+ (idx + str.TOPLEVEL_SUFFIX.length + 1 != name.length || !name.endsWith(str.TOPLEVEL_SUFFIX))
+ }
 
- def isFlatName(classRep: ClassRepresentation): Boolean = {
- val idx = classRep.name.indexOf('$')
- idx >= 0 && idx < classRep.name.length - 1
+ /** Name of class contains `$`, excepted names ending in `$package` */
+ def hasFlatName(classRep: ClassRepresentation): Boolean = {
+ val name = classRep.name
+ val idx = name.lastIndexOf('$', name.length - 2)
+ idx >= 0 &&
+ (idx + str.TOPLEVEL_SUFFIX.length + 1 != name.length || !name.endsWith(str.TOPLEVEL_SUFFIX))
  }
 
  def maybeModuleClass(classRep: ClassRepresentation): Boolean = classRep.name.last == '$'
@@ -253,11 +261,11 @@ object SymbolLoaders {
  val classReps = classPath.list(packageName).classesAndSources
 
  for (classRep <- classReps)
- if (!maybeModuleClass(classRep) && isFlatName(classRep) == flat &&
+ if (!maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
  (!flat || isAbsent(classRep))) // on 2nd enter of flat names, check that the name has not been entered before
  initializeFromClassPath(root.symbol, classRep)
  for (classRep <- classReps)
- if (maybeModuleClass(classRep) && isFlatName(classRep) == flat &&
+ if (maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
  isAbsent(classRep))
  initializeFromClassPath(root.symbol, classRep)
  }