Merge branch 'master' into 'topic/sbt1'

Author: allanrenucci

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

@@ -81,6 +81,7 @@ class Compiler {
          new CrossCastAnd,           // Normalize selections involving intersection types.
          new Splitter) ::            // Expand selections involving union types into conditionals
     List(new ErasedDecls,            // Removes all erased defs and vals decls (except for parameters)
+         new IsInstanceOfChecker,    // check runtime realisability for `isInstanceOf`
          new VCInlineMethods,        // Inlines calls to value class methods
          new SeqLiterals,            // Express vararg arguments as arrays
          new InterceptedMethods,     // Special handling of `==`, `|=`, `getClass` methods

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

@@ -429,7 +429,6 @@ object desugar {
         }
         val hasRepeatedParam = constrVparamss.exists(_.exists {
           case ValDef(_, tpt, _) => isRepeated(tpt)
-          case _ => false
         })
         if (mods.is(Abstract) || hasRepeatedParam) Nil  // cannot have default arguments for repeated parameters, hence copy method is not issued
         else {
@@ -805,7 +804,7 @@ object desugar {
    *  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
+    var mods = synthetic | Artifact
     if (inlineable) mods |= Inline
     Block(
       DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(mods),

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

@@ -771,7 +771,7 @@ object Trees {
   def flatten[T >: Untyped](trees: List[Tree[T]]): List[Tree[T]] = {
     var buf: ListBuffer[Tree[T]] = null
     var xs = trees
-    while (xs.nonEmpty) {
+    while (!xs.isEmpty) {
       xs.head match {
         case Thicket(elems) =>
           if (buf == null) {
@@ -805,7 +805,7 @@ object Trees {
     def unforced: AnyRef
     protected def force(x: AnyRef): Unit
     def forceIfLazy(implicit ctx: Context): T = unforced match {
-      case lzy: Lazy[T] =>
+      case lzy: Lazy[T @unchecked] =>
         val x = lzy.complete
         force(x)
         x

compiler/src/dotty/tools/dotc/config/Properties.scala

@@ -56,7 +56,7 @@ trait PropertiesTrait {
   def scalaPropOrElse(name: String, alt: String): String = scalaProps.getProperty(name, alt)
   def scalaPropOrEmpty(name: String): String             = scalaPropOrElse(name, "")
   def scalaPropOrNone(name: String): Option[String]      = Option(scalaProps.getProperty(name))
-  
+
   /** Either the development or release version if known, otherwise
    *  the empty string.
    */
@@ -73,7 +73,15 @@ trait PropertiesTrait {
       } else ""
     }
   }
-  
+
+  /** Whether the current version of compiler is experimental
+   *
+   *  1. Snapshot and nightly releases are experimental.
+   *  2. Features supported by experimental versions of the compiler:
+   *     - research plugins
+   */
+  val experimental = versionString.contains("SNAPSHOT") || versionString.contains("NIGHTLY")
+
   val copyrightString       = scalaPropOrElse("copyright.string", "(c) 2002-2017 LAMP/EPFL")
 
   /** This is the encoding to use reading in source files, overridden with -encoding

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

@@ -64,7 +64,7 @@ trait Hashable {
     var h = seed
     var xs = tps
     var len = arity
-    while (xs.nonEmpty) {
+    while (!xs.isEmpty) {
       val elemHash = typeHash(bs, xs.head)
       if (elemHash == NotCached) return NotCached
       h = hashing.mix(h, elemHash)

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

@@ -547,13 +547,15 @@ object Names {
   private[this] var size = 1
 
   /** The hash of a name made of from characters cs[offset..offset+len-1].  */
-  private def hashValue(cs: Array[Char], offset: Int, len: Int): Int =
-    if (len > 0)
-      (len * (41 * 41 * 41) +
-        cs(offset) * (41 * 41) +
-        cs(offset + len - 1) * 41 +
-        cs(offset + (len >> 1)))
-    else 0
+  private def hashValue(cs: Array[Char], offset: Int, len: Int): Int = {
+    var i = offset
+    var hash = 0
+    while (i < len + offset) {
+      hash = 31 * hash + cs(i)
+      i += 1
+    }
+    hash
+  }
 
   /** Is (the ASCII representation of) name at given index equal to
    *  cs[offset..offset+len-1]?

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

@@ -519,23 +519,17 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     def mergeParams(ps1: List[TypeParamRef], ps2: List[TypeParamRef]) =
       (ps1 /: ps2)((ps1, p2) => if (ps1.contains(p2)) ps1 else p2 :: ps1)
 
-    def mergeEntries(e1: Type, e2: Type): Type = e1 match {
-        case e1: TypeBounds =>
-          e2 match {
-            case e2: TypeBounds => e1 & e2
-            case _ if e1 contains e2 => e2
-            case _ => mergeError
-          }
-        case tv1: TypeVar =>
-          e2 match {
-            case tv2: TypeVar if tv1.instanceOpt eq tv2.instanceOpt => e1
-            case _ => mergeError
-          }
+    // Must be symmetric
+    def mergeEntries(e1: Type, e2: Type): Type =
+      (e1, e2) match {
         case _ if e1 eq e2 => e1
-        case _ => mergeError
-    }
-
-    def mergeError = throw new AssertionError(i"cannot merge $this with $other")
+        case (e1: TypeBounds, e2: TypeBounds) => e1 & e2
+        case (e1: TypeBounds, _) if e1 contains e2 => e2
+        case (_, e2: TypeBounds) if e2 contains e1 => e1
+        case (tv1: TypeVar, tv2: TypeVar) if tv1.instanceOpt eq tv2.instanceOpt => e1
+        case _ =>
+          throw new AssertionError(i"cannot merge $this with $other, mergeEntries($e1, $e2) failed")
+      }
 
     val that = other.asInstanceOf[OrderingConstraint]
     new OrderingConstraint(

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

@@ -385,10 +385,6 @@ object Phases {
     override def toString = phaseName
   }
 
-  trait NeedsCompanions {
-    def isCompanionNeeded(cls: ClassSymbol)(implicit ctx: Context): Boolean
-  }
-
   /** Replace all instances of `oldPhaseClass` in `current` phases
    *  by the result of `newPhases` applied to the old phase.
    */

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

@@ -45,7 +45,7 @@ case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
   final def consistentParams(that: Signature): Boolean = {
     @tailrec def loop(names1: List[TypeName], names2: List[TypeName]): Boolean =
       if (names1.isEmpty) names2.isEmpty
-      else names2.nonEmpty && consistent(names1.head, names2.head) && loop(names1.tail, names2.tail)
+      else !names2.isEmpty && consistent(names1.head, names2.head) && loop(names1.tail, names2.tail)
     loop(this.paramsSig, that.paramsSig)
   }
 

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

@@ -2862,15 +2862,16 @@ object Types {
 
     type This = MethodType
 
+    val paramInfos = paramInfosExp(this)
+    val resType = resultTypeExp(this)
+    assert(resType.exists)
+
     def companion: MethodTypeCompanion
 
     final override def isJavaMethod: Boolean = companion eq JavaMethodType
     final override def isImplicitMethod: Boolean = companion.eq(ImplicitMethodType) || companion.eq(ErasedImplicitMethodType)
     final override def isErasedMethod: Boolean = companion.eq(ErasedMethodType) || companion.eq(ErasedImplicitMethodType)
 
-    val paramInfos = paramInfosExp(this)
-    val resType = resultTypeExp(this)
-    assert(resType.exists)
 
     def computeSignature(implicit ctx: Context): Signature = {
       val params = if (isErasedMethod) Nil else paramInfos