dev/core/super/com/google/gwt/dev/jjs/intrinsic/com/google/gwt/lang/Exceptions.java

/*
 * Copyright 2008 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.lang;

import com.google.gwt.core.client.JavaScriptException;
import com.google.gwt.core.client.impl.StackTraceCreator;

import javaemul.internal.annotations.DoNotInline;

/**
 * This is a magic class the compiler uses to throw and check exceptions.
 */
final class Exceptions {

  @DoNotInline // This frame can be useful in understanding the native stack
  static Object toJava(Object e) {
    // Although this is impossible to happen in code generated from Java (as we always unwrap
    // before throwing), there are code out there where the Java exception is instantiated and
    // thrown in native code, hence we may receive it already wrapped.
    if (e instanceof Throwable) {
      return e;
    }

    Throwable javaException = getJavaException(e);
    if (javaException == null) {
      javaException = new JavaScriptException(e);
      StackTraceCreator.captureStackTrace(javaException);
    }
    return javaException;
  }

  @DoNotInline // This method shouldn't be inlined and pruned as JsStackEmulator needs it.
  static native Object toJs(Object t)/*-{
    return t.@Throwable::backingJsObject;
  }-*/;

  private static native Throwable getJavaException(Object e)/*-{
    return e && e.__java$exception;
  }-*/;

  static AssertionError makeAssertionError() {
    return new AssertionError();
  }

  /*
   * We use nonstandard naming here so it's easy for the compiler to map to
   * method names based on primitive type name.
   */
  // CHECKSTYLE_OFF
  static AssertionError makeAssertionError_boolean(boolean message) {
    return new AssertionError(message);
  }

  static AssertionError makeAssertionError_char(char message) {
    return new AssertionError(message);
  }

  static AssertionError makeAssertionError_double(double message) {
    return new AssertionError(message);
  }

  static AssertionError makeAssertionError_float(float message) {
    return new AssertionError(message);
  }

  static AssertionError makeAssertionError_int(int message) {
    return new AssertionError(message);
  }

  static AssertionError makeAssertionError_long(long message) {
    return new AssertionError(message);
  }

  static AssertionError makeAssertionError_Object(Object message) {
    return new AssertionError(message);
  }

  /**
   * Throws a TypeError if the argument is null. Otherwise,
   * returns the argument.
   *
   * <p>The GWT compiler inserts calls to this method as a debugging aid, but
   * they will be removed in production compiles. We don't throw a
   * NullPointerException to make it harder to accidentally write code that
   * works in development and fails in production.
   *
   * <p> Instead of attempting to catch this exception, we recommend adding
   * an explicit null check and throwing java.lang.NullPointerException,
   * so that the GWT compiler doesn't remove the null check you're depending on.
   */
  static native <T> T checkNotNull(T arg) /*-{
    if (arg == null) {
      throw new TypeError("null pointer");
    }
    return arg;
  }-*/;

  /**
   * Use by the try-with-resources construct. Look at
   * {@link com.google.gwt.dev.jjs.impl.GwtAstBuilder.createCloseBlockFor}.
   *
   * @param resource a resource implementing the AutoCloseable interface.
   * @param mainException  an exception being propagated.
   * @return an exception to propagate or {@code null} if none.
   */
  static Throwable safeClose(AutoCloseable resource, Throwable mainException) {
    if (resource == null) {
      return mainException;
    }

    try {
      resource.close();
    } catch (Throwable e) {
      if (mainException == null) {
        return e;
      }
      mainException.addSuppressed(e);
    }
    return mainException;
  }
  // CHECKSTYLE_ON
}