scala · odersky · Mar 14, 2017 · Mar 10, 2017 · Mar 11, 2017 · Mar 11, 2017
diff --git a/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala b/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
@@ -49,7 +49,7 @@ class CollectEntryPoints extends MiniPhaseTransform {
 object CollectEntryPoints{
   def isJavaMainMethod(sym: Symbol)(implicit ctx: Context) = {
     (sym.name == nme.main) && (sym.info match {
-      case r@MethodType(_, List(defn.ArrayOf(t))) =>
+      case r@MethodTpe(_, List(defn.ArrayOf(t)), _) =>
         (t.widenDealias =:= defn.StringType) && (
         r.resultType.widenDealias =:= defn.UnitType)
       case _ => false
@@ -81,9 +81,8 @@ object CollectEntryPoints{
     val possibles = if (sym.flags is Flags.Module) (toDenot(sym).info nonPrivateMember nme.main).alternatives else Nil
     val hasApproximate = possibles exists { m =>
       m.info match {
-        case MethodType(_, p :: Nil) =>
-          p.typeSymbol == defn.ArrayClass
-        case _                       => false
+        case MethodTpe(_, p :: Nil, _) => p.typeSymbol == defn.ArrayClass
+        case _                         => false
       }
     }
     // At this point it's a module with a main-looking method, so either succeed or warn that it isn't.
@@ -108,8 +107,8 @@ object CollectEntryPoints{
             toDenot(m.symbol).info match {
               case t: PolyType =>
                 fail("main methods cannot be generic.")
-              case t@MethodType(paramNames, paramTypes) =>
-                if (t.resultType :: paramTypes exists (_.typeSymbol.isAbstractType))
+              case MethodTpe(paramNames, paramTypes, resultType) =>
+                if (resultType :: paramTypes exists (_.typeSymbol.isAbstractType))
                   fail("main methods cannot refer to type parameters or abstract types.", m.symbol.pos)
                 else
                   isJavaMainMethod(m.symbol) || fail("main method must have exact signature (Array[String])Unit", m.symbol.pos)

diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -531,7 +531,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     tree match {
       case Apply(fun, args) =>
         fun.tpe.widen match {
-          case MethodType(names, _) =>
+          case MethodType(names) =>
             names zip args
         }
     }

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -185,12 +185,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     def valueParamss(tp: Type): (List[List[TermSymbol]], Type) = tp match {
-      case tp @ MethodType(paramNames, paramTypes) =>
+      case tp: MethodType =>
         def valueParam(name: TermName, info: Type): TermSymbol = {
           val maybeImplicit = if (tp.isInstanceOf[ImplicitMethodType]) Implicit else EmptyFlags
           ctx.newSymbol(sym, name, TermParam | maybeImplicit, info)
         }
-        val params = (paramNames, paramTypes).zipped.map(valueParam)
+        val params = (tp.paramNames, tp.paramTypes).zipped.map(valueParam)
         val (paramss, rtp) = valueParamss(tp.instantiate(params map (_.termRef)))
         (params :: paramss, rtp)
       case tp => (Nil, tp.widenExpr)

diff --git a/compiler/src/dotty/tools/dotc/config/Config.scala b/compiler/src/dotty/tools/dotc/config/Config.scala
@@ -88,6 +88,10 @@ object Config {
    */
   final val checkHKApplications = false
 
+  /** If this flag is set, method types are checked for valid parameter references
+   */
+  final val checkMethodTypes = false
+
   /** The recursion depth for showing a summarized string */
   final val summarizeDepth = 2
 

diff --git a/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala b/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala
@@ -23,7 +23,7 @@ class JavaPlatform extends Platform {
   // The given symbol is a method with the right name and signature to be a runnable java program.
   def isJavaMainMethod(sym: SymDenotation)(implicit ctx: Context) =
     (sym.name == nme.main) && (sym.info match {
-      case t@MethodType(_, defn.ArrayOf(el) :: Nil) => el =:= defn.StringType && (t.resultType isRef defn.UnitClass)
+      case MethodTpe(_, defn.ArrayOf(el) :: Nil, restpe) => el =:= defn.StringType && (restpe isRef defn.UnitClass)
       case _ => false
     })
 

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -308,13 +308,13 @@ object Denotations {
               case tp2: TypeBounds if tp2 contains tp1 => tp1
               case _ => mergeConflict(tp1, tp2)
             }
-          case tp1 @ MethodType(names1, formals1) if isTerm =>
+          case tp1: MethodType if isTerm =>
             tp2 match {
-              case tp2 @ MethodType(names2, formals2) if ctx.typeComparer.matchingParams(formals1, formals2, tp1.isJava, tp2.isJava) &&
+              case tp2: MethodType if ctx.typeComparer.matchingParams(tp1.paramTypes, tp2.paramTypes, tp1.isJava, tp2.isJava) &&
                 tp1.isImplicit == tp2.isImplicit =>
                 tp1.derivedMethodType(
-                  mergeNames(names1, names2, nme.syntheticParamName),
-                  formals1,
+                  mergeNames(tp1.paramNames, tp2.paramNames, nme.syntheticParamName),
+                  tp1.paramTypes,
                   infoMeet(tp1.resultType, tp2.resultType.subst(tp2, tp1)))
               case _ =>
                 mergeConflict(tp1, tp2)
@@ -471,14 +471,14 @@ object Denotations {
             case tp2: TypeBounds if tp2 contains tp1 => tp2
             case _ => mergeConflict(tp1, tp2)
           }
-        case tp1 @ MethodType(names1, formals1) =>
+        case tp1: MethodType =>
           tp2 match {
-            case tp2 @ MethodType(names2, formals2)
-            if ctx.typeComparer.matchingParams(formals1, formals2, tp1.isJava, tp2.isJava) &&
+            case tp2: MethodType
+            if ctx.typeComparer.matchingParams(tp1.paramTypes, tp2.paramTypes, tp1.isJava, tp2.isJava) &&
               tp1.isImplicit == tp2.isImplicit =>
               tp1.derivedMethodType(
-                mergeNames(names1, names2, nme.syntheticParamName),
-                formals1, tp1.resultType | tp2.resultType.subst(tp2, tp1))
+                mergeNames(tp1.paramNames, tp2.paramNames, nme.syntheticParamName),
+                tp1.paramTypes, tp1.resultType | tp2.resultType.subst(tp2, tp1))
             case _ =>
               mergeConflict(tp1, tp2)
           }

diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -252,7 +252,7 @@ trait Symbols { this: Context =>
 
   /** Create a class constructor symbol for given class `cls`. */
   def newConstructor(cls: ClassSymbol, flags: FlagSet, paramNames: List[TermName], paramTypes: List[Type], privateWithin: Symbol = NoSymbol, coord: Coord = NoCoord) =
-    newSymbol(cls, nme.CONSTRUCTOR, flags | Method, MethodType(paramNames, paramTypes)(_ => cls.typeRef), privateWithin, coord)
+    newSymbol(cls, nme.CONSTRUCTOR, flags | Method, MethodType(paramNames, paramTypes, cls.typeRef), privateWithin, coord)
 
   /** Create an empty default constructor symbol for given class `cls`. */
   def newDefaultConstructor(cls: ClassSymbol) =

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -484,11 +484,11 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         case _ =>
       }
       either(isSubType(tp1, tp21), isSubType(tp1, tp22)) || fourthTry(tp1, tp2)
-    case tp2 @ MethodType(_, formals2) =>
+    case tp2: MethodType =>
       def compareMethod = tp1 match {
-        case tp1 @ MethodType(_, formals1) =>
+        case tp1: MethodType =>
           (tp1.signature consistentParams tp2.signature) &&
-            matchingParams(formals1, formals2, tp1.isJava, tp2.isJava) &&
+            matchingParams(tp1.paramTypes, tp2.paramTypes, tp1.isJava, tp2.isJava) &&
             (tp1.isImplicit == tp2.isImplicit) &&
             isSubType(tp1.resultType, tp2.resultType.subst(tp2, tp1))
         case _ =>
@@ -503,7 +503,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         // as members of the same type. And it seems most logical to take
         // ()T <:< => T, since everything one can do with a => T one can
         // also do with a ()T by automatic () insertion.
-        case tp1 @ MethodType(Nil, _) => isSubType(tp1.resultType, restpe2)
+        case tp1 @ MethodType(Nil) => isSubType(tp1.resultType, restpe2)
         case _ => isSubType(tp1.widenExpr, restpe2)
       }
       compareExpr