Emit a warning when the "requires" keyword is used.

@param statement the statement to check.
543838
@Check
	public void checkRequiredCapacityUse(SarlRequiredCapacity statement) {
		warning(MessageFormat.format(
				Messages.SARLValidator_0,
				this.grammarAccess.getRequiresKeyword()),
				statement,
				null);
	}
1218948
@Override
	protected void prepareStatement(Statement statement) {
		if (statement instanceof DelegatingStatement) {
			injectWebDriver(((DelegatingStatement) statement).getStatement());
		} else {
			injectWebDriver(statement);
		}
	}
530282
public static void close(Statement stmt) {
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException ex) {
                logger.error("", ex);
            }
        }
    }
1176576
public void executeStatements(String... statements) throws SQLException {
    Preconditions.checkNotNull(this.conn, "The Hive connection must be set before any queries can be run");

    for (String statement : statements) {
      if (isSimulate) {
        LOG.info("[SIMULATE MODE] STATEMENT NOT RUN: " + choppedStatementNoLineChange(statement));
      } else {
        LOG.info("RUNNING STATEMENT: " + choppedStatementNoLineChange(statement));
        try (Statement stmt = this.conn.createStatement()) {
          try {
            stmt.execute(statement);
          } catch (SQLException sqe) {
            LOG.error("Failed statement: " + choppedStatementNoLineChange(statement));
            throw sqe;
          }
        }
      }
    }
  }
843221
public void fireStatementErrorOccured(Statement st, SQLException ex) {
    if (st instanceof PreparedStatement) {
      StatementEvent event = new StatementEvent(this, (PreparedStatement) st, ex);
      for (StatementEventListener listener : statementEventListeners) {
        listener.statementErrorOccurred(event);
      }
    }
  }
1121389
public static void requireArgValid(@NotNull final String name, @NotNull final String value) throws ConstraintViolationException {
        // CHECKSTYLE:ON
        final String trimmedValue = value.trim();
        if (!isValid(trimmedValue)) {
            throw new ConstraintViolationException("The argument '" + name + "' is not valid: '" + trimmedValue + "'");
        }
    }
1169440
public static String parseExplainCall(String statement)
    {
        Matcher matcher = ExplainCallPreamble.matcher(statement);
        if ( ! matcher.lookingAt()) {
            return null;
        }
        return statement.substring(matcher.end());
    }
403641
boolean requires(final String value) {
        if (requires(myPrefix, value) || requires(myPostfix, value)) {
            return true;
        }

        if (mySuffixes == null) {
            return false;
        }
        for (final Literal suffix : mySuffixes) {
            if (requires(suffix, value)) {
                return true;
            }
        }
        return false;
    }
338242
public static void closeStatement(final Statement st) {
        if (st == null) {
            return;
        }

        try {
            st.close();
        } catch (Exception e) {
            if (LOG.isWarnEnabled()) LOG.warn("Error closing Statement: " + st, e);
        }
    }
136281
private void executeConsistencyLevelStatement(Tree statement)
    {
        if (!CliMain.isConnected())
            return;

        String userSuppliedLevel = statement.getChild(0).getText().toUpperCase();

        try
        {
            consistencyLevel = ConsistencyLevel.valueOf(userSuppliedLevel);
        }
        catch (IllegalArgumentException e)
        {
            String elements = "ONE, TWO, THREE, QUORUM, ALL, LOCAL_QUORUM, EACH_QUORUM, ANY";
            sessionState.out.println(String.format("'%s' is invalid. Available: %s", userSuppliedLevel, elements));
            return;
        }

        sessionState.out.println(String.format("Consistency level is set to '%s'.", consistencyLevel));
    }
535360
public static void requireValid(@NotNull final Validator validator, @NotNull final Object value, @Nullable final Class<?>... groups)
            throws ConstraintViolationException {
        // CHECKSTYLE:ON

        final Set<ConstraintViolation<Object>> constraintViolations = validator.validate(value);
        if (constraintViolations.size() > 0) {
            final StringBuffer sb = new StringBuffer();
            for (final ConstraintViolation<Object> constraintViolation : constraintViolations) {
                if (sb.length() > 0) {
                    sb.append(", ");
                }
                sb.append("[" + constraintViolation.getPropertyPath() + "] " + constraintViolation.getMessage() + " {"
                        + constraintViolation.getInvalidValue() + "}");
            }
            throw new ConstraintViolationException(sb.toString(), constraintViolations);
        }

    }
1142935
public int[] executeBatchPreparedStatement(String statement, Collection inParamsBatch) throws SQLException {
		return executeBatchPreparedStatement(statement, inParamsBatch, true);
	}
1061901
function dsStatement(statement) {
  switch(statement.constructor) {
    case Statements.Blank:
    case Statements.Conditional:
    case Statements.DialogueSegment:
    case Statements.Evaluate:
    case Statements.Function:
    case Statements.Link:
    case Statements.Option:
    case Statements.OptionGroup:
    case Statements.Shortcut:
    case Statements.ShortcutGroup:
      return false;
    case Statements.Command:
    case Statements.LineGroup:
    case Statements.Text:
    case Statements.Hashtag:
      return true;
    default: 
      console.warn(`Unrecognized statement type: ${statement.constructor.name}`);
      return false;
  }
}
1118969
static void requireArgument(boolean expression, String template, @Nullable Object... args) {
    if (!expression) {
      throw new IllegalArgumentException(String.format(template, args));
    }
  }
111173
public static String parseExplainJSONCall(String statement)
    {
        Matcher matcher = ExplainJSONCallPreamble.matcher(statement);
        if ( ! matcher.lookingAt()) {
            return null;
        }
        return statement.substring(matcher.end());
    }
840916
function validateStatement(node, keywordName) {
            const option = getOption(keywordName);

            if (node.type === "BlockStatement" || option === "any") {
                return;
            }

            const tokenBefore = sourceCode.getTokenBefore(node);

            if (tokenBefore.loc.end.line === node.loc.start.line && option === "below") {
                context.report({
                    node,
                    message: "Expected a linebreak before this statement.",
                    fix: fixer => fixer.insertTextBefore(node, "\n")
                });
            } else if (tokenBefore.loc.end.line !== node.loc.start.line && option === "beside") {
                context.report({
                    node,
                    message: "Expected no linebreak before this statement.",
                    fix(fixer) {
                        if (sourceCode.getText().slice(tokenBefore.range[1], node.range[0]).trim()) {
                            return null;
                        }
                        return fixer.replaceTextRange([tokenBefore.range[1], node.range[0]], " ");
                    }
                });
            }
        }
819037
@Override
    public void warn( F0<String> msg )
    {
        if ( compilerLogger.isWarnEnabled() )
        {
            compilerLogger.warn( msg.apply() );
        }
    }