Scala 2.10.3编译器中可能存在的错误

我遇到了一些类似以下的代码：

object SomeOddThing extends App {
  val c: C = new C
  val a: A = c
  val b: B = c
  // these will all print None
  println(a.x)
  println(b.x)
  println(c.x)
}

abstract class A {
  def x: Option[String] = None
}

abstract class B extends A {
  override def x: Option[String] = Some("xyz")
}

class C extends B {
  // x now has type None.type instead of Option[String]
  override def x = None
}

trait T {
  this: B =>
  override def x = Some("ttt")
}

// this won't compile with the following error
// error: overriding method x in class C of type => None.type;
//  method x in trait T of type => Some[String] has incompatible type
// class D extends C with T {}
//       ^
class D extends C with T {}

---

对我来说这看起来像个虫子。应正确推断

C.x

的类型，或者该类根本不应编译。

规范4.6.4仅承诺为覆盖方法的结果类型推断一致类型

看看吧，感谢你没有扔

也许它会改变：

更新：

协变结果类型是自然的。它推断出它通常会做什么并不奇怪。你不能再加宽字体了。正如另一个问题所说，这可能是次优的。（说到我的评论，这是一种改进，而不是缺陷本身。）

我对ML的评论是：

这属于“始终注释接口方法，包括 子类扩展的接口。“

在很多情况下，对API方法使用推断类型会将您提交到一个您原本避免的类型。对于呈现给子类的接口也是如此

对于这个问题，我们要求编译器保留最后一个显式指定的类型，这是合理的，除非它不是。也许我们的意思是不要推断单例类型，或者什么都没有，或者诸如此类/自言自语

scala> trait A ; trait B extends A ; trait C extends B
defined trait A
defined trait B
defined trait C

scala> trait X { def f: A }
defined trait X

scala> trait Y extends X { def f: B }
defined trait Y

scala> trait Z extends Y { def f: C }
defined trait Z

scala> trait X { def f: A = new A {} }
defined trait X

scala> trait Y extends X { override def f: B = new B {} }
defined trait Y

scala> trait Z extends Y { override def f: C = new C {} }
defined trait Z

scala> trait ZZ extends Z { override def f: A = new C {} }
<console>:13: error: overriding method f in trait Z of type => C;
 method f has incompatible type
       trait ZZ extends Z { override def f: A = new C {} }
                                         ^

scala>trait A；性状B延伸A；性状C延伸到B
定义特征A
定义性状B
定义性状C
scala>trait X{def f:A}
定义性状X
scala>trait Y扩展X{def f:B}
定义性状Y
scala>trait Z扩展了Y{def f:C}
定义性状Z
scala>trait X{def f:A=newa{}
定义性状X
scala>trait Y扩展X{override def:B=new B{}
定义性状Y
scala>trait Z扩展了Y{override def:C=new C{}
定义性状Z
scala>trait ZZ扩展了Z{override def:A=newc{}
：13：错误：重写类型=>C的特征Z中的方法f；
方法f的类型不兼容
trait ZZ扩展了Z{override def:A=new C{}
^

对于这个问题，None.type符合选项意味着什么

scala> implicitly[None.type <:< Option[_]]
res0: <:<[None.type,Option[_]] = <function1>

scala>隐式[None.type现在有一个