12.13 The throw statement
480861
function parseThrowStatement() {
        var argument;

        expectKeyword('throw');

        if (peekLineTerminator()) {
            throwError({}, Messages.NewlineAfterThrow);
        }

        argument = parseExpression();

        consumeSemicolon();

        return delegate.createThrowStatement(argument);
    }
115631
public void doCatch(Throwable caughtException) throws Throwable {
		
		breakTsxRepeatLoop = true;
		if(caughtException instanceof ArrayIndexOutOfBoundsException || caughtException instanceof  NoSuchElementException){
			doOutput (true);	// only output for certain exceptions.
		}
		else{
			logger.logp(Level.SEVERE,CLASS_NAME, "doCatch","Caught unexpected exception in tsx:repeat. breaking loop @["+ currentIteration +"]",caughtException);
			doOutput(false);	// do not write output from tag to client.
		}

	}
329839
function throwIf (target /*, illegal... */) {
    Array.prototype.slice.call(arguments, 1).forEach(function (name) {
      if (options[name]) {
        throw new Error('Cannot set ' + name + ' and ' + target + 'together');
      }
    });
  }
1094845
function getThrowStatementOwner(throwStatement) {
                    var child = throwStatement;
                    while (child.parent) {
                        var parent_22 = child.parent;
                        if (ts.isFunctionBlock(parent_22) || parent_22.kind === 256 /* SourceFile */) {
                            return parent_22;
                        }
                        // A throw-statement is only owned by a try-statement if the try-statement has
                        // a catch clause, and if the throw-statement occurs within the try block.
                        if (parent_22.kind === 216 /* TryStatement */) {
                            var tryStatement = parent_22;
                            if (tryStatement.tryBlock === child && tryStatement.catchClause) {
                                return child;
                            }
                        }
                        child = parent_22;
                    }
                    return undefined;
                }
229561
function throwEqualError( F, a, b ) {
		if ( (F[a] || F[b]) && (F[a] === F[b]) ) {
			throw new Error(a);
		}
	}
246733
@Override
    public void setThrown(Throwable thrown) {
        if (thrown != null) {
            super.setThrown(thrown);
            this.ivStackTrace = DataFormatHelper.throwableToString(thrown);
        }
    }
937980
@Incubating
    public static <T> T argLambdaThrowing(ThrowingPredicate<T> throwingLambda, String description) {
        return argThat(new LambdaMatcher<>(throwingLambda.uncheck(), description));
    }
1136482
def throws(exc):
    '''
    
    '''
    if not __CHECKING__:
        return lambda f: f

    def wrap(f):
        def call(*args, **kwd):
            res = f(*args, **kwd)
            # raise UncheckedExceptionError if exc is not automatically
            # registered by a function decorated with @catches(exc);
            # otherwise do nothing
            exc_checker.throwing(exc)
            return res
        call.__name__ = f.__name__
        return call
    return wrap
1231760
private function _throw() {
    $node = new ThrowStatementNode();
    $this->mustMatch(T_THROW, $node);
    $node->addChild($this->expr(), 'expression');
    $this->endStatement($node);
    return $node;
  }
876907
@SuppressWarnings("unused")
    private // until I can get this to work
    <T extends Throwable> void rethrowCauseOfType(Class<T> type)
        throws Throwable // this should be throws T
    {
        T cause = causeOfType(type);

        // rethrow acts as if its always throwing Throwable, not the subclass.
        if (cause != null) throw cause;
    }
809419
@SuppressWarnings("unchecked")
    private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }
709344
function() {
  let args = Array.prototype.slice.call(arguments),
    ErrorClass = args[0];

  if (_.isObject(ErrorClass)) {
    args.shift();
  } else {
    ErrorClass = errors.RuntimeError;
  }

  args.unshift(null);   // the this arg for the .bind() call

  throw new (Function.prototype.bind.apply(ErrorClass, args));
}
1150380
@Nonnull
  public IMPLTYPE _throw (@Nonnull final IJSExpression aExpr)
  {
    addStatement (new JSThrow (aExpr));
    return thisAsT ();
  }
186949
public void doCatch(Throwable t) throws Throwable {
        if (conn != null) {
            try {
                conn.rollback();
            } catch (SQLException e) {
                // Ignore to not hide orignal exception
            }
        }
        throw t;
    }
973990
public void noExceptionThrown() {
    Throwable thrown = getSpecificationContext().getThrownException();
    if (thrown == null) return;
    throw new UnallowedExceptionThrownError(null, thrown);
  }
437772
public void throwNotIn(@SuppressWarnings("unchecked") Class<? extends Throwable>... classes) {
                boolean toThrow = true;
                for (Class<? extends Throwable> cls : classes) {
                        if (cls.isInstance(super.getCause())) {
                                toThrow = false;
                                break;
                        }
                }
                if (toThrow) {
                        throw this;
                }
        }
712010
private ParseTree parseThrowStatement() {
    SourcePosition start = getTreeStartLocation();
    eat(TokenType.THROW);
    ParseTree value = null;
    if (peekImplicitSemiColon()) {
      reportError("semicolon/newline not allowed after 'throw'");
    } else {
      value = parseExpression();
    }
    eatPossibleImplicitSemiColon();
    return new ThrowStatementTree(getTreeLocation(start), value);
  }