具有默认 null 的 Scala 按名称参数抛出 NullPointerException

Question

以下代码片段抛出 NullPointerException。这是 Scala 的预期和正常行为吗？

object ATest extends App {
    def getX[T <: X](constr: ⇒ T = null.asInstanceOf[T]): Unit = {
        constr
    }
    getX()
}
class X

从片段生成(反编译)Java 代码:

public final class ATest {
public static void main(String[] arrstring) {
    ATest$.MODULE$.main(arrstring);
}
public static void delayedInit(Function0<BoxedUnit> function0) {
    ATest$.MODULE$.delayedInit(function0);
}
public static String[] args() {
    return ATest$.MODULE$.args();
}
public static void scala$App$_setter_$executionStart_$eq(long l) {
    ATest$.MODULE$.scala$App$_setter_$executionStart_$eq(l);
}
public static long executionStart() {
    return ATest$.MODULE$.executionStart();
}
public static void delayedEndpoint$test$ATest$1() {
    ATest$.MODULE$.delayedEndpoint$test$ATest$1();
}
public static <T extends X> T getX$default$1() {
    return ATest$.MODULE$.getX$default$1();
}
public static <T extends X> void getX(Function0<T> function0) {
    ATest$.MODULE$.getX(function0);
}
}


public final class ATest$ implements App {
public static final ATest$ MODULE$;
private final long executionStart;
private String[] scala$App$$_args;
private final ListBuffer<Function0<BoxedUnit>> scala$App$$initCode;

public static {
    new test.ATest$();
}
public long executionStart() {
    return this.executionStart;
}
public String[] scala$App$$_args() {
    return this.scala$App$$_args;
}
public void scala$App$$_args_$eq(String[] x$1) {
    this.scala$App$$_args = x$1;
}
public ListBuffer<Function0<BoxedUnit>> scala$App$$initCode() {
    return this.scala$App$$initCode;
}
public void scala$App$_setter_$executionStart_$eq(long x$1) {
    this.executionStart = x$1;
}
public void scala$App$_setter_$scala$App$$initCode_$eq(ListBuffer x$1) {
    this.scala$App$$initCode = x$1;
}
public String[] args() {
    return App.class.args((App)this);
}
public void delayedInit(Function0<BoxedUnit> body) {
    App.class.delayedInit((App)this, body);
}
public void main(String[] args) {
    App.class.main((App)this, (String[])args);
}
public <T extends X> void getX(Function0<T> constr) {
    constr.apply();
}
public <T extends X> T getX$default$1() {
    return null;
}
public final void delayedEndpoint$test$ATest$1() {
    this.getX((Function0<T>)new scala.Serializable(){
        public static final long serialVersionUID = 0;

        public final Nothing. apply() {
            return (Nothing.)ATest$.MODULE$.getX$default$1();
        }
    });
}
private ATest$() {
    MODULE$ = this;
    App.class.$init$((App)this);
    this.delayedInit((Function0<BoxedUnit>)new ATest.delayedInit$body(this));
}
}

public final class ATest$.anonfun extends AbstractFunction0<Nothing.>implements Serializable {
public final Nothing. apply() {
        return (Nothing.)ATest$.MODULE$.getX$default$1();
        }
}

---

最后是 Action 部分:

public <T extends X> void getX(Function0<T> constr) {
    constr.apply();
}
public <T extends X> T getX$default$1() {
    return null;
}
public final void delayedEndpoint$test$ATest$1() {
    this.getX((Function0<T>)new scala.Serializable(){
        public final Nothing. apply() {
            return (Nothing.)ATest$.MODULE$.getX$default$1();
        }
    });
}

即:对 getX 的调用传递了新的匿名 Function0，它的 apply() 只是调用 getX$default$1()，它是 null。所以我看不到任何可以抛出 NPE 的点。

编辑:发现 Unresolved 问题:https://issues.scala-lang.org/browse/SI-8097

编辑:表达式 null.asInstanceOf[T] 为类型 T 生成默认值。如果 Scala 将结果类型 T 推断为 Nothing，我们将进入运行时表达式

null.asInstanceOf[Nothing]

这显然将 Exeption 作为 Nothing is Exception 的默认值抛出。

但是为什么这段代码只在最后一行抛出 NPE？

object ATest extends App {
    def getX[T](x: T = null.asInstanceOf[T]): T = x
    getX[Nothing]() // Ok
    val x = getX() // Ok 
    val y = null
    println("x= "+x) // prints 'x= null'
    println(s"y= $y") // prints 'y= null'
    println(s"x= $x") // throws NPE !?
    println("x==null ? "+(x==null)) // prints 'x= null'
}

为什么这个代码片段会抛出 NPE(它只是与之前的隐式参数不同)？

object ATest extends App {
    def getX[T](x: T = null.asInstanceOf[T])(implicit s: String = null): T = x
    getX() // throws NPE !?
}

所以情况还很模糊。问题是开放的。

Answer 1

所以我必须稍微修改一下我的答案。

然而，从字节码中可以清楚地知道是什么触发了 NPE，但在反向编译的 Java 代码中却不清楚。字节代码比 Java 代码具有更多的特性，重要的是，您可以拥有两个仅在返回类型上不同的方法并执行不同的操作。

所以让我们首先看一下堆栈跟踪:

at ATest$$anonfun$1.apply(Test.scala:7)
at ATest$.getX(Test.scala:5)
at ATest$.delayedEndpoint$ATest$1(Test.scala:7)
at ATest$delayedInit$body.apply(Test.scala:3)
at scala.Function0$class.apply$mcV$sp(Function0.scala:40)
at scala.runtime.AbstractFunction0.apply$mcV$sp(AbstractFunction0.scala:12)
at scala.App$$anonfun$main$1.apply(App.scala:76)
at scala.App$$anonfun$main$1.apply(App.scala:76)
at scala.collection.immutable.List.foreach(List.scala:383)
at scala.collection.generic.TraversableForwarder$class.foreach(TraversableForwarder.scala:35)
at scala.App$class.main(App.scala:76)
at ATest$.main(Test.scala:3)
at ATest.main(Test.scala)

所以出错的方法是 ATest$$anonfun$1.apply

让我们看看:

public final scala.runtime.Nothing$ apply();
Code:
   0: getstatic     #19                 // Field ATest$.MODULE$:LATest$;
   3: invokevirtual #23                 // Method ATest$.getX$default$1:()LX;
   6: checkcast     #25                 // class scala/runtime/Nothing$
   9: areturn

public final java.lang.Object apply();
Code:
   0: aload_0
   1: invokevirtual #30                 // Method apply:()Lscala/runtime/Nothing$;
   4: athrow

首先我们注意到有两个方法叫apply，所以调用了哪个(throw是一个提示...)好吧，让我们看看调用它的方法:

public <T extends X> void getX(scala.Function0<T>);
Code:
   0: aload_1
   1: invokeinterface #62,  1  // InterfaceMethod scala/Function0.apply:()Ljava/lang/Object;
   6: pop
   7: return

因此，我们正在调用返回对象并具有抛出指令的对象。那么，为什么会出现 NullPointer 异常？

好吧，该方法执行以下操作:它将 this 放入堆栈，然后调用另一个应用方法(返回 Nothing$)，该方法实际上返回 null，因为它返回我们的默认参数。现在我们在堆栈上有一个 null 并执行 throw。如果 throw 在堆栈上发现 null，则会抛出 NPE。

这就是这里发生的事情。

下一个问题是，为什么会这样？

好吧，让我们看看在类型检查之后 scalac 是如何处理它的:

object ATest extends AnyRef with App {
    def <init>(): ATest.type = {
      ATest.super.<init>();
      ()
    };
    def getX[T <: X](constr: => T = null.asInstanceOf[T]): Unit = {
      constr;
      ()
    };
    <synthetic> def getX$default$1[T <: X]: T = null.asInstanceOf[T];
    ATest.this.getX[Nothing](ATest.this.getX$default$1[Nothing])
  }

在没有 asInstanceOf 的情况下它做了什么:

object ATest extends AnyRef with App {
    def <init>(): ATest.type = {
      ATest.super.<init>();
      ()
    };
    def getX[T <: X](constr: => T = null): Unit = {
      constr;
      ()
    };
    <synthetic> def getX$default$1[T <: X]: Null = null;
    ATest.this.getX[Null](ATest.this.getX$default$1[Nothing])
  }

好吧，在第一种情况下，默认参数为 Null 的信息以某种方式丢失了。

在第二种情况下，我们得到关键方法的字节码:

public final java.lang.Object apply();
Code:
   0: aload_0
   1: invokevirtual #27                 // Method apply:()Lscala/runtime/Null$;
   4: pop
   5: aconst_null
   6: areturn

所以在这里，编译器知道参数为 null，并使用 Null$ 类生成代码以将 null 装箱。

应该发生什么？

当然不是空指针异常。但是为什么编译器首先生成那个 throw 呢？可能是因为 asInstanceOf[T] 变成了 asInstanceOf[Nothing]，如果在 null 上调用它应该抛出异常。

让我们快速尝试一下，如果我们在 repl 中这样做会发生什么:

"".asInstanceOf[Nothing]
java.lang.ClassCastException: java.lang.String cannot be cast to scala.runtime.Nothing$

到目前为止一切顺利，而且:

null.asInstanceOf[Nothing]
java.lang.NullPointerException

好吧，也许我应该从这个开始......似乎，asInstanceOf 的代码生成有一些错误并抛出错误的异常。

为什么下限 :> Null 解决了这个问题，也很清楚:推断的类型不再是 Nothing，而是 Null 并且 instanceOf 很好。

所以更有趣的问题是为什么类型检查器在您现在已删除的复杂示例上失败。

复杂的例子

class X
object ATest extends App {
  def getX[T<:X](clas: Class[T], constr: ⇒ T = null): T ={
    val x = constr
    if (x == null) clas.newInstance() else x
  }
  val clas: Class[_ <: X] = classOf[X]
  getX(clas) // Ooops: type mismatch..
}

那么，类型检查器会说什么:

def getX[T <: X](clas: Class[T], constr: => T = null): T = {
  val x: T = constr;
    if (x.==(null))
      clas.newInstance()
    else
      x
  };
  <synthetic> def getX$default$2[T <: X]: Null = null;
  private[this] val clas: Class[_ <: X] = classOf[X];
  <stable> <accessor> def clas: Class[_ <: X] = ATest.this.clas;
  ATest.this.getX[T](<clas: error>, ATest.this.getX$default$2)
}

他无法以某种方式推断出 T 的类型，但他应该推断出 Null，因为只有引用类型的类。有趣的是，编译器并不知道这一点。好像是直接用Java中Class的定义，那里的类型参数没有下界(因为Java没有Null类型)，所以下界是Nothing。这也告诉我们如何修复它:

val clas: Class[_ >: Null <: X] = classOf[X]
getX(clas)

这终于奏效了。所以你可以准确地做你一开始想做的事情。您只需告诉编译器，您对不能为空的类型的类不感兴趣。

不过，我想我还是更喜欢带有 Option 的版本:

def getX[T <: X](clas: Class[T], constr: ⇒ Option[T] = None): T = {
  val x = constr
   x match {
    case None => clas.newInstance()
    case Some(x) => x
  }
}
val clas: Class[_ <: X] = classOf[X]
getX(clas)

现在也清楚了，为什么会这样:None 是一个 Option[Nothing]，所以这段代码可以很好地处理 Class[Nothing]。