Merge branch 'master'

Author: OlivierBlanvillain

.drone.yml

@@ -23,29 +23,29 @@ pipeline:
   # We run tests in parallel. Tests run in a copy of the working directory to avoid conflict
   test:
     group: test
-    image: lampepfl/dotty:2018-05-23
+    image: lampepfl/dotty:2018-06-29
     commands:
       - cp -R . /tmp/1/ && cd /tmp/1/
       - ./project/scripts/sbt ";compile ;test"
       - ./project/scripts/cmdTests
 
   test_bootstrapped:
     group: test
-    image: lampepfl/dotty:2018-05-23
+    image: lampepfl/dotty:2018-06-29
     commands:
       - cp -R . /tmp/2/ && cd /tmp/2/
       - ./project/scripts/sbt ";dotty-bootstrapped/compile ;dotty-bootstrapped/test"
 
   test_optimised:
     group: test
-    image: lampepfl/dotty:2018-05-23
+    image: lampepfl/dotty:2018-06-29
     commands:
       - cp -R . /tmp/3/ && cd /tmp/3/
       - ./project/scripts/sbt dotty-optimised/test
 
   test_sbt:
     group: test
-    image: lampepfl/dotty:2018-05-23
+    image: lampepfl/dotty:2018-06-29
     commands:
       - cp -R . /tmp/4/ && cd /tmp/4/
       - ./project/scripts/sbt sbt-dotty/scripted
@@ -55,7 +55,7 @@ pipeline:
 
   # DOCUMENTATION:
   documentation:
-    image: lampepfl/dotty:2018-05-23
+    image: lampepfl/dotty:2018-06-29
     commands:
       - ./project/scripts/genDocs
     secrets: [ bot_pass ]
@@ -67,7 +67,7 @@ pipeline:
   # PUBLISHING:
   # Publishing expect NIGHTLYBUILD or RELEASEBUILD to be set. See dottyVersion in Build.scala
   publish_nightly:
-    image: lampepfl/dotty:2018-05-23
+    image: lampepfl/dotty:2018-06-29
     environment:
       - NIGHTLYBUILD=yes
     commands:
@@ -78,7 +78,7 @@ pipeline:
       environment: nightly
 
   publish_release:
-    image: lampepfl/dotty:2018-05-23
+    image: lampepfl/dotty:2018-06-29
     environment:
       - RELEASEBUILD=yes
     commands:
@@ -102,7 +102,7 @@ pipeline:
       event: tag
 
   publish_sbt_release:
-    image: lampepfl/dotty:2018-05-23
+    image: lampepfl/dotty:2018-06-29
     environment:
       - RELEASEBUILD=yes
     commands:

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -258,7 +258,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
       case t: TypeApply if (t.fun.symbol == Predef_classOf) =>
         av.visit(name, t.args.head.tpe.classSymbol.denot.info.toTypeKind(bcodeStore)(innerClasesStore).toASMType)
       case t: tpd.Select =>
-        if (t.symbol.denot.owner.is(Flags.Enum)) {
+        if (t.symbol.denot.owner.is(Flags.JavaEnum)) {
           val edesc = innerClasesStore.typeDescriptor(t.tpe.asInstanceOf[bcodeStore.int.Type]) // the class descriptor of the enumeration class.
           val evalue = t.symbol.name.mangledString // value the actual enumeration value.
           av.visitEnum(name, edesc, evalue)
@@ -710,7 +710,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def isBottomClass: Boolean = (sym ne defn.NullClass) && (sym ne defn.NothingClass)
     def isBridge: Boolean = sym is Flags.Bridge
     def isArtifact: Boolean = sym is Flags.Artifact
-    def hasEnumFlag: Boolean = sym is Flags.Enum
+    def hasEnumFlag: Boolean = sym is Flags.JavaEnum
     def hasAccessBoundary: Boolean = sym.accessBoundary(defn.RootClass) ne defn.RootClass
     def isVarargsMethod: Boolean = sym is Flags.JavaVarargs
     def isDeprecated: Boolean = false
@@ -842,7 +842,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def superInterfaces: List[Symbol] = {
       val directlyInheritedTraits = decorateSymbol(sym).directlyInheritedTraits
       val directlyInheritedTraitsSet = directlyInheritedTraits.toSet
-      val allBaseClasses = directlyInheritedTraits.iterator.flatMap(_.symbol.asClass.baseClasses.drop(1)).toSet
+      val allBaseClasses = directlyInheritedTraits.iterator.flatMap(_.asClass.baseClasses.drop(1)).toSet
       val superCalls = superCallsMap.getOrElse(sym, Set.empty)
       val additional = (superCalls -- directlyInheritedTraitsSet).filter(_.is(Flags.Trait))
 //      if (additional.nonEmpty)

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -41,13 +41,9 @@ class GenBCode extends Phase {
 
   private[this] var myOutput: AbstractFile = _
 
-  protected def outputDir(implicit ctx: Context): AbstractFile = {
-    if (myOutput eq null) {
-      val path = Directory(ctx.settings.outputDir.value)
-      myOutput =
-        if (path.extension == "jar") JarArchive.create(path)
-        else new PlainDirectory(path)
-    }
+  private def outputDir(implicit ctx: Context): AbstractFile = {
+    if (myOutput eq null)
+      myOutput = ctx.settings.outputDir.value
     myOutput
   }
 

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -37,7 +37,7 @@ object CompilationUnit {
 
   /** Make a compilation unit for top class `clsd` with the contends of the `unpickled` */
   def mkCompilationUnit(clsd: ClassDenotation, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit =
-    mkCompilationUnit(new SourceFile(clsd.symbol.associatedFile, Seq()), unpickled, forceTrees)
+    mkCompilationUnit(SourceFile(clsd.symbol.associatedFile, Array.empty), unpickled, forceTrees)
 
   /** Make a compilation unit, given picked bytes and unpickled tree */
   def mkCompilationUnit(source: SourceFile, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit = {

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -60,13 +60,13 @@ class Compiler {
   protected def transformPhases: List[List[Phase]] =
     List(new FirstTransform,         // Some transformations to put trees into a canonical form
          new CheckReentrant,         // Internal use only: Check that compiled program has no data races involving global vars
-         new ProtectedAccessors,     // Add accessors for protected members
          new ElimPackagePrefixes) :: // Eliminate references to package prefixes in Select nodes
     List(new CheckStatic,            // Check restrictions that apply to @static members
          new ElimRepeated,           // Rewrite vararg parameters and arguments
          new NormalizeFlags,         // Rewrite some definition flags
-         new ExtensionMethods,       // Expand methods of value classes with extension methods
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
+         new ProtectedAccessors,     // Add accessors for protected members
+         new ExtensionMethods,       // Expand methods of value classes with extension methods
          new ShortcutImplicits,      // Allow implicit functions without creating closures
          new TailRec,                // Rewrite tail recursion to loops
          new ByNameClosures,         // Expand arguments to by-name parameters to closures

compiler/src/dotty/tools/dotc/Driver.scala

@@ -2,7 +2,9 @@ package dotty.tools.dotc
 
 import dotty.tools.FatalError
 import config.CompilerCommand
+import core.Comments.{ContextDoc, ContextDocstrings}
 import core.Contexts.{Context, ContextBase}
+import core.Mode
 import util.DotClass
 import reporting._
 import scala.util.control.NonFatal
@@ -44,6 +46,11 @@ class Driver extends DotClass {
     val ctx = rootCtx.fresh
     val summary = CompilerCommand.distill(args)(ctx)
     ctx.setSettings(summary.sstate)
+
+    if (!ctx.settings.YdropComments.value(ctx) || ctx.mode.is(Mode.ReadComments)) {
+      ctx.setProperty(ContextDoc, new ContextDocstrings)
+    }
+
     val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)(ctx)
     (fileNames, ctx)
   }

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

@@ -78,7 +78,7 @@ object desugar {
           case tp: NamedType if tp.symbol.exists && (tp.symbol.owner eq originalOwner) =>
             val defctx = ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next()
             var local = defctx.denotNamed(tp.name ++ suffix).suchThat(_.isParamOrAccessor).symbol
-            if (local.exists) (defctx.owner.thisType select local).dealias
+            if (local.exists) (defctx.owner.thisType select local).dealiasKeepAnnots
             else {
               def msg =
                 s"no matching symbol for ${tp.symbol.showLocated} in ${defctx.owner} / ${defctx.effectiveScope.toList}"
@@ -297,8 +297,8 @@ object desugar {
     val isCaseClass  = mods.is(Case) && !mods.is(Module)
     val isCaseObject = mods.is(Case) && mods.is(Module)
     val isImplicit = mods.is(Implicit)
-    val isEnum = mods.hasMod[Mod.Enum] && !mods.is(Module)
-    val isEnumCase = mods.hasMod[Mod.EnumCase]
+    val isEnum = mods.isEnumClass && !mods.is(Module)
+    def isEnumCase = mods.isEnumCase
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
       // This is not watertight, but `extends AnyVal` will be replaced by `inline` later.
 
@@ -641,7 +641,7 @@ object desugar {
     val moduleName = checkNotReservedName(mdef).asTermName
     val impl = mdef.impl
     val mods = mdef.mods
-    lazy val isEnumCase = mods.hasMod[Mod.EnumCase]
+    def isEnumCase = mods.isEnumCase
     if (mods is Package)
       PackageDef(Ident(moduleName), cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
     else if (isEnumCase)
@@ -688,7 +688,7 @@ object desugar {
    */
   def patDef(pdef: PatDef)(implicit ctx: Context): Tree = flatTree {
     val PatDef(mods, pats, tpt, rhs) = pdef
-    if (mods.hasMod[Mod.EnumCase])
+    if (mods.isEnumCase)
       pats map {
         case id: Ident =>
           expandSimpleEnumCase(id.name.asTermName, mods,
@@ -810,16 +810,11 @@ object desugar {
    *  ==>
    *      def $anonfun(params) = body
    *      Closure($anonfun)
-   *
-   *  If `inlineable` is true, tag $anonfun with an @inline annotation.
    */
-  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), inlineable: Boolean)(implicit ctx: Context) = {
-    var mods = synthetic | Artifact
-    if (inlineable) mods |= Inline
+  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), isImplicit: Boolean)(implicit ctx: Context) =
     Block(
-      DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(mods),
-      Closure(Nil, Ident(nme.ANON_FUN), EmptyTree))
-  }
+      DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(synthetic | Artifact),
+      Closure(Nil, Ident(nme.ANON_FUN), if (isImplicit) ImplicitEmptyTree else EmptyTree))
 
   /** If `nparams` == 1, expand partial function
    *
@@ -863,7 +858,7 @@ object desugar {
 
   def makeImplicitFunction(formals: List[Type], body: Tree)(implicit ctx: Context): Tree = {
     val params = makeImplicitParameters(formals.map(TypeTree))
-    new NonEmptyFunction(params, body, Modifiers(Implicit))
+    new FunctionWithMods(params, body, Modifiers(Implicit))
   }
 
   /** Add annotation to tree:
@@ -1114,8 +1109,8 @@ object desugar {
           case Block(Nil, expr) => expr // important for interpolated string as patterns, see i1773.scala
           case t => t
         }
-
-        Apply(Select(Apply(Ident(nme.StringContext), strs), id), elems)
+        // This is a deliberate departure from scalac, where StringContext is not rooted (See #4732)
+        Apply(Select(Apply(scalaDot(nme.StringContext), strs), id), elems)
       case InfixOp(l, op, r) =>
         if (ctx.mode is Mode.Type)
           AppliedTypeTree(op, l :: r :: Nil) // op[l, r]

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

@@ -33,8 +33,8 @@ object DesugarEnums {
 
   /** Is `tree` an (untyped) enum case? */
   def isEnumCase(tree: Tree)(implicit ctx: Context): Boolean = tree match {
-    case tree: MemberDef => tree.mods.hasMod[Mod.EnumCase]
-    case PatDef(mods, _, _, _) => mods.hasMod[Mod.EnumCase]
+    case tree: MemberDef => tree.mods.isEnumCase
+    case PatDef(mods, _, _, _) => mods.isEnumCase
     case _ => false
   }
 
@@ -69,7 +69,7 @@ object DesugarEnums {
 
   /** Add implied flags to an enum class or an enum case */
   def addEnumFlags(cdef: TypeDef)(implicit ctx: Context) =
-    if (cdef.mods.hasMod[Mod.Enum]) cdef.withMods(cdef.mods.withFlags(cdef.mods.flags | Abstract | Sealed))
+    if (cdef.mods.isEnumClass) cdef.withMods(cdef.mods.withFlags(cdef.mods.flags | Abstract | Sealed))
     else if (isEnumCase(cdef)) cdef.withMods(cdef.mods.withFlags(cdef.mods.flags | Final))
     else cdef
 

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

@@ -240,6 +240,35 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case y          => y
   }
 
+  /**  The largest subset of {NoInits, PureInterface} that a
+   *   trait or class enclosing this statement can have as flags.
+   */
+  def defKind(tree: Tree)(implicit ctx: Context): FlagSet = unsplice(tree) match {
+    case EmptyTree | _: Import => NoInitsInterface
+    case tree: TypeDef => if (tree.isClassDef) NoInits else NoInitsInterface
+    case tree: DefDef =>
+      if (tree.unforcedRhs == EmptyTree &&
+          tree.vparamss.forall(_.forall(_.rhs.isEmpty))) NoInitsInterface
+      else NoInits
+    case tree: ValDef => if (tree.unforcedRhs == EmptyTree) NoInitsInterface else EmptyFlags
+    case _ => EmptyFlags
+  }
+
+  /**  The largest subset of {NoInits, PureInterface} that a
+   *   trait or class with these parents can have as flags.
+   */
+  def parentsKind(parents: List[Tree])(implicit ctx: Context): FlagSet = parents match {
+    case Nil => NoInitsInterface
+    case Apply(_, _ :: _) :: _ => EmptyFlags
+    case _ :: parents1 => parentsKind(parents1)
+  }
+
+  /**  The largest subset of {NoInits, PureInterface} that a
+   *   trait or class with this body can have as flags.
+   */
+  def bodyKind(body: List[Tree])(implicit ctx: Context): FlagSet =
+    (NoInitsInterface /: body)((fs, stat) => fs & defKind(stat))
+
   /** Checks whether predicate `p` is true for all result parts of this expression,
    *  where we zoom into Ifs, Matches, and Blocks.
    */
@@ -298,11 +327,15 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
 
   /** Is `tree` an implicit function or closure, possibly nested in a block? */
   def isImplicitClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
+    case tree: FunctionWithMods => tree.mods.is(Implicit)
     case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Implicit)
     case Closure(_, meth, _) => true
     case Block(Nil, expr) => isImplicitClosure(expr)
-    case Block(DefDef(nme.ANON_FUN, _, (param :: _) :: _, _, _) :: Nil, _: Closure) =>
-      param.mods.is(Implicit)
+    case Block(DefDef(nme.ANON_FUN, _, params :: _, _, _) :: Nil, cl: Closure) =>
+      params match {
+        case param :: _ => param.mods.is(Implicit)
+        case Nil => cl.tpt.eq(untpd.ImplicitEmptyTree) || defn.isImplicitFunctionType(cl.tpt.typeOpt)
+      }
     case _ => false
   }
 
@@ -354,6 +387,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       refPurity(tree)
     case Select(qual, _) =>
       refPurity(tree).min(exprPurity(qual))
+    case New(_) =>
+      SimplyPure
     case TypeApply(fn, _) =>
       exprPurity(fn)
 /*
@@ -365,13 +400,12 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case Apply(fn, args) =>
       def isKnownPureOp(sym: Symbol) =
         sym.owner.isPrimitiveValueClass || sym.owner == defn.StringClass
-      // Note: After uncurry, field accesses are represented as Apply(getter, Nil),
-      // so an Apply can also be pure.
-      if (args.isEmpty && fn.symbol.is(Stable)) exprPurity(fn)
-      else if (tree.tpe.isInstanceOf[ConstantType] && isKnownPureOp(tree.symbol))
-        // A constant expression with pure arguments is pure.
+      if (tree.tpe.isInstanceOf[ConstantType] && isKnownPureOp(tree.symbol)
+             // A constant expression with pure arguments is pure.
+          || fn.symbol.isStable)
         minOf(exprPurity(fn), args.map(exprPurity)) `min` Pure
-      else Impure
+      else
+        Impure
     case Typed(expr, _) =>
       exprPurity(expr)
     case Block(stats, expr) =>
@@ -398,11 +432,16 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *  @DarkDimius: need to make sure that lazy accessor methods have Lazy and Stable
    *               flags set.
    */
-  def refPurity(tree: Tree)(implicit ctx: Context): PurityLevel =
-    if (!tree.tpe.widen.isParameterless || tree.symbol.is(Erased)) SimplyPure
-    else if (!tree.symbol.isStable) Impure
-    else if (tree.symbol.is(Lazy)) Idempotent // TODO add Module flag, sinxce Module vals or not Lazy from the start.
+  def refPurity(tree: Tree)(implicit ctx: Context): PurityLevel = {
+    val sym = tree.symbol
+    if (!tree.hasType) Impure
+    else if (!tree.tpe.widen.isParameterless || sym.is(Erased)) SimplyPure
+    else if (!sym.isStable) Impure
+    else if (sym.is(Module))
+      if (sym.moduleClass.isNoInitsClass) Pure else Idempotent
+    else if (sym.is(Lazy)) Idempotent
     else SimplyPure
+  }
 
   def isPureRef(tree: Tree)(implicit ctx: Context) =
     refPurity(tree) == SimplyPure
@@ -547,6 +586,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   /** An extractor for def of a closure contained the block of the closure. */
   object closureDef {
     def unapply(tree: Tree): Option[DefDef] = tree match {
+      case Block(Nil, expr) => unapply(expr)
       case Block((meth @ DefDef(nme.ANON_FUN, _, _, _, _)) :: Nil, closure: Closure) =>
         Some(meth)
       case _ => None
@@ -618,17 +658,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     accum(Nil, root)
   }
 
-  /**  The largest subset of {NoInits, PureInterface} that a
-   *   trait enclosing this statement can have as flags.
-   */
-  def defKind(tree: Tree): FlagSet = unsplice(tree) match {
-    case EmptyTree | _: Import => NoInitsInterface
-    case tree: TypeDef => if (tree.isClassDef) NoInits else NoInitsInterface
-    case tree: DefDef => if (tree.unforcedRhs == EmptyTree) NoInitsInterface else NoInits
-    case tree: ValDef => if (tree.unforcedRhs == EmptyTree) NoInitsInterface else EmptyFlags
-    case _ => EmptyFlags
-  }
-
   /** The top level classes in this tree, including only those module classes that
    *  are not a linked class of some other class in the result.
    */