【问题标题】:Scala by-name parameter with default null throws NullPointerException具有默认 null 的 Scala 按名称参数抛出 NullPointerException
【发布时间】:2016-03-11 14:55:56
【问题描述】:

下面的 sn-p 抛出 NullPointerException。 这是 Scala 的预期和正常行为吗?

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

从 sn-p 生成(反编译)的 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();
        }
}

最后是动作部分:

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() 只调用了 null 的 getX$default$1()。所以我看不到任何可以抛出 NPE 的点。

编辑:发现未解决的问题:https://issues.scala-lang.org/browse/SI-8097

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

null.asInstanceOf[Nothing]

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

但是为什么这个 sn-p 只在最后一行抛出 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'
}

以及为什么这个 sn-p 会抛出 NPE(它与之前的隐式参数不同)?

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

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

【问题讨论】:

  • 我无法使用 Scala 2.11.7 重现 NPE,请参阅 gist.github.com/lrytz/1c05e0fa666b130e2d38 - 你使用的是什么版本?
  • 可以用 Scala 2.11.7 和 Java 1.7 重现这个。
  • 噢,我的错,跑错了主目录。
  • 该示例在使用 Scala 2.12.0-M3 时不会发生 NPE - 除非我再次出错,欢迎确认!我认为崩溃实际上是正确的(不同的异常可能更有用),并且 2.12.0-M3 可能是错误的。问题是类型检查器为类型参数 T 推断出 Nothing(使用 -Xprint:typer),并且 null 不是 Nothing 类型的有效值(Nothing 没有有效类型)。所以 null.asInstanceOf[Nothing] 崩溃了——它还能做什么?
  • 有趣,我可以确认。同样在 repl 中,如果您尝试 "".instanceOf[Nothing],您将不再获得空指针,相反,您会被告知,在 instanceOf 中不能使用 Nothing。看起来他们已经摆脱了该代码,但仍未正确处理该案例。

标签: scala


【解决方案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,那么调用哪个(抛出是一个提示......)好吧,让我们看看调用它的方法:

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

所以,我们调用的是返回一个 Object 并具有 athrow 指令的那个。那么为什么这会给我们一个 NullPointer 异常呢?

这个方法做了以下事情:它把 this 放到栈上,然后调用另一个 apply 方法(返回一个 Nothing$),这个方法实际上返回 null,因为它返回我们的默认参数。现在我们在堆栈上有一个空值并执行抛出。如果在堆栈上找到 null,则 athrow 会抛出 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$ 生成代码以将空框设置为空。

应该发生什么?

嗯,肯定不是空指针异常。但是为什么编译器首先会生成那个抛出?可能是因为 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]。

【讨论】:

  • 我添加了反编译的代码。我仍然认为没有地方可以扔 NPE。
  • 顺便说一句,解决此问题的另一种方法是为具有null 值的抽象类型添加通常的约束:def getX[T &gt;: Null &lt;: X]
  • 所以,我希望我现在已经弄清楚了一切;)
  • 感谢您深入研究问题。很有意思。最后我在这里发现了一个未解决的问题:issues.scala-lang.org/browse/SI-8097
  • 不确定您是否知道 null.asInstanceOf 在规范中。 scala-lang.org/files/archive/spec/2.11/…上面对null和Nothing的解释不是很准确。
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2013-08-07
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多