Added code for adapt and more.

- Pushed mode into context
- Elimintaed scope nesting level
- Fixed a desugar bug
- Added constant folding

4 files changed, 45 insertions, 27 deletions

diff --git a/src/dotty/tools/dotc/core/Contexts.scala b/src/dotty/tools/dotc/core/Contexts.scala
index f7adbc184..ee67ec76e 100644
--- a/src/dotty/tools/dotc/core/Contexts.scala
+++ b/src/dotty/tools/dotc/core/Contexts.scala
@@ -79,12 +79,9 @@ object Contexts {
     def period: Period = _period
 
     /** The scope nesting level */
-    private[this] var _scopeNestingLevel: Int = 0
-    def scopeNestingLevel: Int = {
-      if (this._scopeNestingLevel == outer.scopeNestingLevel && this.scope != outer.scope)
-        this._scopeNestingLevel = outer.scopeNestingLevel + 1
-      this._scopeNestingLevel
-    }
+    private[this] var _mode: Mode = _
+    protected def mode_=(mode: Mode) = _mode = mode
+    def mode: Mode = _mode
 
     /** The current type comparer */
     private[this] var _typerState: TyperState = _
@@ -249,6 +246,7 @@ object Contexts {
       if (_condensed eq outer.condensed)
         _condensed = base.initialCtx.fresh
           .withPeriod(period)
+          .withMode(mode)
           // typerState and its constraint is not preserved in condensed
           // reporter is always ThrowingReporter
           .withPlainPrinter(plainPrinter)
@@ -272,6 +270,13 @@ object Contexts {
       newctx.setCreationTrace()
       newctx
     }
+
+    def withMode(mode: Mode): Context =
+      if (mode != this.mode) fresh.withMode(mode) else this
+
+    def addMode(mode: Mode): Context = withMode(this.mode | mode)
+    def maskMode(mode: Mode): Context = withMode(this.mode & mode)
+    def retractMode(mode: Mode): Context = withMode(this.mode &~ mode)
   }
 
   /** A condensed context provides only a small memory footprint over
@@ -287,6 +292,7 @@ object Contexts {
    */
   abstract class FreshContext extends CondensedContext {
     def withPeriod(period: Period): this.type = { this.period = period; this }
+    override def withMode(mode: Mode): this.type = { this.mode = mode; this }
     def withTyperState(typerState: TyperState): this.type = { this.typerState = typerState; this }
     def withNewTyperState: this.type = withTyperState(typerState.fresh)
     def withPosition(position: Position): this.type = { this.position = position; this }
@@ -311,8 +317,6 @@ object Contexts {
       withSettings(setting.updateIn(sstate, value))
 
     def withDebug = withSetting(base.settings.debug, true)
-    def withImplicitsDisabled: this.type = ???
-    def silent: this.type = ???
   }
 
   /** A class defining the initial context with given context base
@@ -321,6 +325,7 @@ object Contexts {
   private class InitialContext(val base: ContextBase, settings: SettingGroup) extends FreshContext {
     outer = NoContext
     period = InitialPeriod
+    mode = Mode.None
     typerState = new TyperState(new ConsoleReporter()(this))
     position = NoPosition
     plainPrinter = new PlainPrinter(_)
diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala
index 66ed61a7f..757240c43 100644
--- a/src/dotty/tools/dotc/core/Definitions.scala
+++ b/src/dotty/tools/dotc/core/Definitions.scala
@@ -152,15 +152,15 @@ class Definitions(implicit ctx: Context) {
   lazy val ArrayClass: ClassSymbol = requiredClass("scala.Array")
   lazy val uncheckedStableClass: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedStable")
 
-  lazy val UnitClass = valueClassSymbol("scala.Unit", BoxedUnitClass, java.lang.Void.TYPE)
-  lazy val BooleanClass = valueClassSymbol("scala.Boolean", BoxedBooleanClass, java.lang.Boolean.TYPE)
-  lazy val ByteClass = valueClassSymbol("scala.Byte", BoxedByteClass, java.lang.Byte.TYPE)
-  lazy val ShortClass = valueClassSymbol("scala.Short", BoxedShortClass, java.lang.Short.TYPE)
-  lazy val CharClass = valueClassSymbol("scala.Char", BoxedCharClass, java.lang.Character.TYPE)
-  lazy val IntClass = valueClassSymbol("scala.Int", BoxedIntClass, java.lang.Integer.TYPE)
-  lazy val LongClass = valueClassSymbol("scala.Long", BoxedLongClass, java.lang.Long.TYPE)
-  lazy val FloatClass = valueClassSymbol("scala.Float", BoxedFloatClass, java.lang.Float.TYPE)
-  lazy val DoubleClass = valueClassSymbol("scala.Double", BoxedDoubleClass, java.lang.Double.TYPE)
+  lazy val UnitClass = valueClassSymbol("scala.Unit", BoxedUnitClass, java.lang.Void.TYPE, UnitEnc)
+  lazy val BooleanClass = valueClassSymbol("scala.Boolean", BoxedBooleanClass, java.lang.Boolean.TYPE, BooleanEnc)
+  lazy val ByteClass = valueClassSymbol("scala.Byte", BoxedByteClass, java.lang.Byte.TYPE, ByteEnc)
+  lazy val ShortClass = valueClassSymbol("scala.Short", BoxedShortClass, java.lang.Short.TYPE, ShortEnc)
+  lazy val CharClass = valueClassSymbol("scala.Char", BoxedCharClass, java.lang.Character.TYPE, CharEnc)
+  lazy val IntClass = valueClassSymbol("scala.Int", BoxedIntClass, java.lang.Integer.TYPE, IntEnc)
+  lazy val LongClass = valueClassSymbol("scala.Long", BoxedLongClass, java.lang.Long.TYPE, LongEnc)
+  lazy val FloatClass = valueClassSymbol("scala.Float", BoxedFloatClass, java.lang.Float.TYPE, FloatEnc)
+  lazy val DoubleClass = valueClassSymbol("scala.Double", BoxedDoubleClass, java.lang.Double.TYPE, DoubleEnc)
 
   lazy val BoxedUnitClass = requiredClass("scala.runtime.BoxedUnit")
   lazy val BoxedBooleanClass = requiredClass("java.lang.Boolean")
@@ -276,6 +276,8 @@ class Definitions(implicit ctx: Context) {
     }
   }
 
+  def isFunctionType(tp: Type) = FunctionClasses contains tp.typeSymbol
+
   // ----- Symbol sets ---------------------------------------------------
 
   lazy val FunctionClass = mkArityArray("Function", MaxFunctionArity, 0)
@@ -377,18 +379,21 @@ class Definitions(implicit ctx: Context) {
 
   private[this] val _javaTypeToValueClass = mutable.Map[Class[_], Symbol]()
   private[this] val _valueClassToJavaType = mutable.Map[Symbol, Class[_]]()
+  private[this] val _valueClassEnc = mutable.Map[Symbol, Int]()
 
   val boxedClass: collection.Map[Symbol, Symbol] = _boxedClass
   val unboxedClass: collection.Map[Symbol, Symbol] = _boxedClass
   val javaTypeToValueClass: collection.Map[Class[_], Symbol] = _javaTypeToValueClass
   val valueClassToJavaType: collection.Map[Symbol, Class[_]] = _valueClassToJavaType
+  val valueClassEnc: collection.Map[Symbol, Int] = _valueClassEnc
 
-  private def valueClassSymbol(name: String, boxed: ClassSymbol, jtype: Class[_]): ClassSymbol = {
+  private def valueClassSymbol(name: String, boxed: ClassSymbol, jtype: Class[_], enc: Int): ClassSymbol = {
     val vcls = requiredClass(name)
     _unboxedClass(boxed) = vcls
     _boxedClass(vcls) = boxed
     _javaTypeToValueClass(jtype) = vcls
     _valueClassToJavaType(vcls) = jtype
+    _valueClassEnc(vcls) = enc
     vcls
   }
 
@@ -399,6 +404,19 @@ class Definitions(implicit ctx: Context) {
     else nme.genericWrapArray
   }
 
+  val ByteEnc = 2
+  val ShortEnc = ByteEnc * 3
+  val CharEnc = 5
+  val IntEnc = ShortEnc * CharEnc
+  val LongEnc = IntEnc * 7
+  val FloatEnc = LongEnc * 11
+  val DoubleEnc = FloatEnc * 13
+  val BooleanEnc = 17
+  val UnitEnc = 19
+
+  def isValueSubClass(cls1: Symbol, cls2: Symbol) =
+    valueClassEnc(cls2) % valueClassEnc(cls1) == 0
+
   // ----- Initialization ---------------------------------------------------
 
   /** Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
diff --git a/src/dotty/tools/dotc/core/TyperState.scala b/src/dotty/tools/dotc/core/TyperState.scala
index 6bf2378ba..e492eee60 100644
--- a/src/dotty/tools/dotc/core/TyperState.scala
+++ b/src/dotty/tools/dotc/core/TyperState.scala
@@ -22,8 +22,6 @@ class TyperState(val reporter: Reporter = ThrowingReporter) extends DotClass {
   def fresh: TyperState = this
 
   def commit()(implicit ctx: Context): Unit = unsupported("commit")
-
-  def copyFrom(tp: TyperState): Unit = unsupported("copyFrom")
 }
 
 class MutableTyperState(previous: TyperState, reporter: Reporter)
@@ -41,13 +39,8 @@ extends TyperState(reporter) {
   override def fresh: TyperState = new MutableTyperState(this, new StoreReporter)
 
   override def commit()(implicit ctx: Context) = {
-    ctx.typerState.copyFrom(this)
+    ctx.typerState.constraint = constraint
+    ctx.typerState.undetVars = undetVars
     reporter.flush()
   }
-
-  override def copyFrom(state: TyperState): Unit = {
-    constraint = state.constraint
-    undetVars = state.undetVars
-  }
-
 }
diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala
index f2b86242d..ef06c37f7 100644
--- a/src/dotty/tools/dotc/core/Types.scala
+++ b/src/dotty/tools/dotc/core/Types.scala
@@ -510,6 +510,8 @@ object Types {
      *  <o.x.type>.widen = o.C
      */
     final def widen(implicit ctx: Context): Type = this match {
+      case tp: TermRef =>
+      	if (tp.denot.isOverloaded) tp else tp.underlying.widen
       case tp: SingletonType => tp.underlying.widen
       case tp: TypeBounds => tp.hi.widen // needed?
       case tp: ExprType => tp.resultType.widen