No OneTemporary
Actions

Size

93 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/lint/ArcanistLintSeverity.php b/src/lint/ArcanistLintSeverity.php
	index 3466cde1..05ec3723 100644
	--- a/src/lint/ArcanistLintSeverity.php
	+++ b/src/lint/ArcanistLintSeverity.php
	@@ -1,57 +1,54 @@
	<?php

	/**
	* Describes the severity of an @{class:ArcanistLintMessage}.
	*
	* @group lint
	*/
	final class ArcanistLintSeverity {

	const SEVERITY_ADVICE = 'advice';
	const SEVERITY_AUTOFIX = 'autofix';
	const SEVERITY_WARNING = 'warning';
	const SEVERITY_ERROR = 'error';
	const SEVERITY_DISABLED = 'disabled';

	public static function getLintSeverities() {
	return array(
	self::SEVERITY_ADVICE => 'Advice',
	self::SEVERITY_AUTOFIX => 'Auto-Fix',
	self::SEVERITY_WARNING => 'Warning',
	self::SEVERITY_ERROR => 'Error',
	self::SEVERITY_DISABLED => 'Disabled',
	);
	}

	public static function getStringForSeverity($severity_code) {
	$map = self::getLintSeverities();

	if (!array_key_exists($severity_code, $map)) {
	throw new Exception("Unknown lint severity '{$severity_code}'!");
	}

	return $map[$severity_code];
	}

	- public static function isAtLeastAsSevere(
	- ArcanistLintMessage $message,
	- $level) {
	+ public static function isAtLeastAsSevere($message_sev, $level) {

	static $map = array(
	self::SEVERITY_DISABLED => 10,
	self::SEVERITY_ADVICE => 20,
	self::SEVERITY_AUTOFIX => 25,
	self::SEVERITY_WARNING => 30,
	self::SEVERITY_ERROR => 40,
	);

	- $message_sev = $message->getSeverity();
	if (empty($map[$message_sev])) {
	return true;
	}

	return $map[$message_sev] >= idx($map, $level, 0);
	}


	}
	diff --git a/src/lint/engine/ArcanistLintEngine.php b/src/lint/engine/ArcanistLintEngine.php
	index 39f995ea..9ea1ddca 100644
	--- a/src/lint/engine/ArcanistLintEngine.php
	+++ b/src/lint/engine/ArcanistLintEngine.php
	@@ -1,454 +1,458 @@
	<?php

	/**
	* Manages lint execution. When you run 'arc lint' or 'arc diff', Arcanist
	* checks your .arcconfig to see if you have specified a lint engine in the
	* key "lint.engine". The engine must extend this class. For example:
	*
	* lang=js
	* {
	* // ...
	* "lint.engine" : "ExampleLintEngine",
	* // ...
	* }
	*
	* The lint engine is given a list of paths (generally, the paths that you
	* modified in your change) and determines which linters to run on them. The
	* linters themselves are responsible for actually analyzing file text and
	* finding warnings and errors. For example, if the modified paths include some
	* JS files and some Python files, you might want to run JSLint on the JS files
	* and PyLint on the Python files.
	*
	* You can also run multiple linters on a single file. For instance, you might
	* run one linter on all text files to make sure they don't have trailing
	* whitespace, or enforce tab vs space rules, or make sure there are enough
	* curse words in them.
	*
	* Because lint engines are pretty custom to the rules of a project, you will
	* generally need to build your own. Fortunately, it's pretty easy (and you
	* can use the prebuilt //linters//, you just need to write a little glue code
	* to tell Arcanist which linters to run). For a simple example of how to build
	* a lint engine, see @{class:ExampleLintEngine}.
	*
	* You can test an engine like this:
	*
	* arc lint --engine ExampleLintEngine --lintall some_file.py
	*
	* ...which will show you all the lint issues raised in the file.
	*
	* See @{article@phabricator:Arcanist User Guide: Customizing Lint, Unit Tests
	* and Workflows} for more information about configuring lint engines.
	*
	* @group lint
	* @stable
	*/
	abstract class ArcanistLintEngine {

	protected $workingCopy;
	protected $paths = array();
	protected $fileData = array();

	protected $charToLine = array();
	protected $lineToFirstChar = array();
	private $cachedResults;
	private $cacheVersion;
	private $repositoryVersion;
	private $results = array();
	private $stopped = array();
	private $minimumSeverity = ArcanistLintSeverity::SEVERITY_DISABLED;

	private $changedLines = array();
	private $commitHookMode = false;
	private $hookAPI;

	private $enableAsyncLint = false;
	private $postponedLinters = array();

	public function __construct() {

	}

	public function setWorkingCopy(ArcanistWorkingCopyIdentity $working_copy) {
	$this->workingCopy = $working_copy;
	return $this;
	}

	public function getWorkingCopy() {
	return $this->workingCopy;
	}

	public function setPaths($paths) {
	$this->paths = $paths;
	return $this;
	}

	public function getPaths() {
	return $this->paths;
	}

	public function setPathChangedLines($path, $changed) {
	if ($changed === null) {
	$this->changedLines[$path] = null;
	} else {
	$this->changedLines[$path] = array_fill_keys($changed, true);
	}
	return $this;
	}

	public function getPathChangedLines($path) {
	return idx($this->changedLines, $path);
	}

	public function setFileData($data) {
	$this->fileData = $data + $this->fileData;
	return $this;
	}

	public function setCommitHookMode($mode) {
	$this->commitHookMode = $mode;
	return $this;
	}

	public function setHookAPI(ArcanistHookAPI $hook_api) {
	$this->hookAPI = $hook_api;
	return $this;
	}

	public function getHookAPI() {
	return $this->hookAPI;
	}

	public function setEnableAsyncLint($enable_async_lint) {
	$this->enableAsyncLint = $enable_async_lint;
	return $this;
	}

	public function getEnableAsyncLint() {
	return $this->enableAsyncLint;
	}

	public function loadData($path) {
	if (!isset($this->fileData[$path])) {
	if ($this->getCommitHookMode()) {
	$this->fileData[$path] = $this->getHookAPI()
	->getCurrentFileData($path);
	} else {
	$disk_path = $this->getFilePathOnDisk($path);
	$this->fileData[$path] = Filesystem::readFile($disk_path);
	}
	}
	return $this->fileData[$path];
	}

	public function pathExists($path) {
	if ($this->getCommitHookMode()) {
	$file_data = $this->loadData($path);
	return ($file_data !== null);
	} else {
	$disk_path = $this->getFilePathOnDisk($path);
	return Filesystem::pathExists($disk_path);
	}
	}

	public function getFilePathOnDisk($path) {
	return Filesystem::resolvePath(
	$path,
	$this->getWorkingCopy()->getProjectRoot());
	}

	public function setMinimumSeverity($severity) {
	$this->minimumSeverity = $severity;
	return $this;
	}

	public function getCommitHookMode() {
	return $this->commitHookMode;
	}

	public function run() {
	$linters = $this->buildLinters();

	if (!$linters) {
	throw new ArcanistNoEffectException("No linters to run.");
	}

	$have_paths = false;
	foreach ($linters as $linter) {
	if ($linter->getPaths()) {
	$have_paths = true;
	break;
	}
	}

	if (!$have_paths) {
	throw new ArcanistNoEffectException("No paths are lintable.");
	}

	$versions = array($this->getCacheVersion());
	foreach ($linters as $linter) {
	$linter->setEngine($this);
	$versions[] = get_class($linter).':'.$linter->getCacheVersion();
	}
	$this->cacheVersion = crc32(implode("\n", $versions));

	$this->stopped = array();
	$exceptions = array();
	foreach ($linters as $linter_name => $linter) {
	if (!is_string($linter_name)) {
	$linter_name = get_class($linter);
	}
	try {
	if (!$linter->canRun()) {
	continue;
	}
	$paths = $linter->getPaths();

	foreach ($paths as $key => $path) {
	// Make sure each path has a result generated, even if it is empty
	// (i.e., the file has no lint messages).
	$result = $this->getResultForPath($path);
	if (isset($this->stopped[$path])) {
	unset($paths[$key]);
	}
	if (isset($this->cachedResults[$path][$this->cacheVersion])) {
	$cached_result = $this->cachedResults[$path][$this->cacheVersion];

	$use_cache = $this->shouldUseCache(
	$linter->getCacheGranularity(),
	idx($cached_result, 'repository_version'));

	if ($use_cache) {
	unset($paths[$key]);

	if (idx($cached_result, 'stopped') == $linter_name) {
	$this->stopped[$path] = $linter_name;
	}
	}
	}
	}
	$paths = array_values($paths);

	if ($paths) {
	$linter->willLintPaths($paths);
	foreach ($paths as $path) {
	$linter->willLintPath($path);
	$linter->lintPath($path);
	if ($linter->didStopAllLinters()) {
	$this->stopped[$path] = $linter_name;
	}
	}
	}

	} catch (Exception $ex) {
	$exceptions[$linter_name] = $ex;
	}
	}

	$this->didRunLinters($linters);

	foreach ($linters as $linter) {
	- $minimum = $this->minimumSeverity;
	foreach ($linter->getLintMessages() as $message) {
	- if (!ArcanistLintSeverity::isAtLeastAsSevere($message, $minimum)) {
	+ if (!$this->isSeverityEnabled($message->getSeverity())) {
	continue;
	}
	if (!$this->isRelevantMessage($message)) {
	continue;
	}
	$message->setGranularity($linter->getCacheGranularity());
	$result = $this->getResultForPath($message->getPath());
	$result->addMessage($message);
	}
	}

	if ($this->cachedResults) {
	foreach ($this->cachedResults as $path => $messages) {
	$messages = idx($messages, $this->cacheVersion, array());
	$repository_version = idx($messages, 'repository_version');
	unset($messages['stopped']);
	unset($messages['repository_version']);
	foreach ($messages as $message) {
	$use_cache = $this->shouldUseCache(
	idx($message, 'granularity'),
	$repository_version);
	if ($use_cache) {
	$this->getResultForPath($path)->addMessage(
	ArcanistLintMessage::newFromDictionary($message));
	}
	}
	}
	}

	foreach ($this->results as $path => $result) {
	$disk_path = $this->getFilePathOnDisk($path);
	$result->setFilePathOnDisk($disk_path);
	if (isset($this->fileData[$path])) {
	$result->setData($this->fileData[$path]);
	} else if ($disk_path && Filesystem::pathExists($disk_path)) {
	// TODO: this may cause us to, e.g., load a large binary when we only
	// raised an error about its filename. We could refine this by looking
	// through the lint messages and doing this load only if any of them
	// have original/replacement text or something like that.
	try {
	$this->fileData[$path] = Filesystem::readFile($disk_path);
	$result->setData($this->fileData[$path]);
	} catch (FilesystemException $ex) {
	// Ignore this, it's noncritical that we access this data and it
	// might be unreadable or a directory or whatever else for plenty
	// of legitimate reasons.
	}
	}
	}

	if ($exceptions) {
	throw new PhutilAggregateException('Some linters failed:', $exceptions);
	}

	return $this->results;
	}

	+ public function isSeverityEnabled($severity) {
	+ $minimum = $this->minimumSeverity;
	+ return ArcanistLintSeverity::isAtLeastAsSevere($severity, $minimum);
	+ }
	+
	private function shouldUseCache($cache_granularity, $repository_version) {
	switch ($cache_granularity) {
	case ArcanistLinter::GRANULARITY_FILE:
	return true;
	case ArcanistLinter::GRANULARITY_DIRECTORY:
	case ArcanistLinter::GRANULARITY_REPOSITORY:
	return ($this->repositoryVersion == $repository_version);
	default:
	return false;
	}
	}

	/**
	* @param dict<string path, dict<string version, list<dict message>>>
	* @return this
	*/
	public function setCachedResults(array $results) {
	$this->cachedResults = $results;
	return $this;
	}

	public function getResults() {
	return $this->results;
	}

	public function getStoppedPaths() {
	return $this->stopped;
	}

	abstract protected function buildLinters();

	protected function didRunLinters(array $linters) {
	assert_instances_of($linters, 'ArcanistLinter');
	foreach ($linters as $linter) {
	$linter->didRunLinters();
	}
	}

	public function setRepositoryVersion($version) {
	$this->repositoryVersion = $version;
	return $this;
	}

	private function isRelevantMessage(ArcanistLintMessage $message) {
	// When a user runs "arc lint", we default to raising only warnings on
	// lines they have changed (errors are still raised anywhere in the
	// file). The list of $changed lines may be null, to indicate that the
	// path is a directory or a binary file so we should not exclude
	// warnings.

	if (!$this->changedLines \|\| $message->isError()) {
	return true;
	}

	$locations = $message->getOtherLocations();
	$locations[] = $message->toDictionary();

	foreach ($locations as $location) {
	$path = idx($location, 'path', $message->getPath());

	if (!array_key_exists($path, $this->changedLines)) {
	continue;
	}

	$changed = $this->getPathChangedLines($path);

	if ($changed === null \|\| !$location['line']) {
	return true;
	}

	$last_line = $location['line'];
	if (isset($location['original'])) {
	$last_line += substr_count($location['original'], "\n");
	}

	for ($l = $location['line']; $l <= $last_line; $l++) {
	if (!empty($changed[$l])) {
	return true;
	}
	}
	}

	return false;
	}

	protected function getResultForPath($path) {
	if (empty($this->results[$path])) {
	$result = new ArcanistLintResult();
	$result->setPath($path);
	$result->setCacheVersion($this->cacheVersion);
	$this->results[$path] = $result;
	}
	return $this->results[$path];
	}

	public function getLineAndCharFromOffset($path, $offset) {
	if (!isset($this->charToLine[$path])) {
	$char_to_line = array();
	$line_to_first_char = array();

	$lines = explode("\n", $this->loadData($path));
	$line_number = 0;
	$line_start = 0;
	foreach ($lines as $line) {
	$len = strlen($line) + 1; // Account for "\n".
	$line_to_first_char[] = $line_start;
	$line_start += $len;
	for ($ii = 0; $ii < $len; $ii++) {
	$char_to_line[] = $line_number;
	}
	$line_number++;
	}
	$this->charToLine[$path] = $char_to_line;
	$this->lineToFirstChar[$path] = $line_to_first_char;
	}

	$line = $this->charToLine[$path][$offset];
	$char = $offset - $this->lineToFirstChar[$path][$line];

	return array($line, $char);
	}

	public function getPostponedLinters() {
	return $this->postponedLinters;
	}

	public function setPostponedLinters(array $linters) {
	$this->postponedLinters = $linters;
	return $this;
	}

	protected function getCacheVersion() {
	return 1;
	}

	protected function getPEP8WithTextOptions() {
	// E101 is subset of TXT2 (Tab Literal).
	// E501 is same as TXT3 (Line Too Long).
	// W291 is same as TXT6 (Trailing Whitespace).
	// W292 is same as TXT4 (File Does Not End in Newline).
	// W293 is same as TXT6 (Trailing Whitespace).
	return '--ignore=E101,E501,W291,W292,W293';
	}

	}
	diff --git a/src/lint/linter/ArcanistLinter.php b/src/lint/linter/ArcanistLinter.php
	index a910accc..1d5867ab 100644
	--- a/src/lint/linter/ArcanistLinter.php
	+++ b/src/lint/linter/ArcanistLinter.php
	@@ -1,241 +1,246 @@
	<?php

	/**
	* Implements lint rules, like syntax checks for a specific language.
	*
	* @group linter
	* @stable
	*/
	abstract class ArcanistLinter {

	const GRANULARITY_FILE = 1;
	const GRANULARITY_DIRECTORY = 2;
	const GRANULARITY_REPOSITORY = 3;
	const GRANULARITY_GLOBAL = 4;

	protected $paths = array();
	protected $data = array();
	protected $engine;
	protected $activePath;
	protected $messages = array();

	protected $stopAllLinters = false;

	private $customSeverityMap = array();
	private $config = array();

	public function setCustomSeverityMap(array $map) {
	$this->customSeverityMap = $map;
	return $this;
	}

	public function setConfig(array $config) {
	$this->config = $config;
	return $this;
	}

	protected function getConfig($key, $default = null) {
	return idx($this->config, $key, $default);
	}

	public function getActivePath() {
	return $this->activePath;
	}

	public function getOtherLocation($offset, $path = null) {
	if ($path === null) {
	$path = $this->getActivePath();
	}

	list($line, $char) = $this->getEngine()->getLineAndCharFromOffset(
	$path,
	$offset);

	return array(
	'path' => $path,
	'line' => $line + 1,
	'char' => $char,
	);
	}

	public function stopAllLinters() {
	$this->stopAllLinters = true;
	return $this;
	}

	public function didStopAllLinters() {
	return $this->stopAllLinters;
	}

	public function addPath($path) {
	$this->paths[$path] = $path;
	return $this;
	}

	public function setPaths(array $paths) {
	$this->paths = $paths;
	return $this;
	}

	public function getPaths() {
	return array_values($this->paths);
	}

	public function addData($path, $data) {
	$this->data[$path] = $data;
	return $this;
	}

	protected function getData($path) {
	if (!array_key_exists($path, $this->data)) {
	$this->data[$path] = $this->getEngine()->loadData($path);
	}
	return $this->data[$path];
	}

	public function setEngine(ArcanistLintEngine $engine) {
	$this->engine = $engine;
	return $this;
	}

	protected function getEngine() {
	return $this->engine;
	}

	public function getCacheVersion() {
	return 0;
	}

	public function getLintMessageFullCode($short_code) {
	return $this->getLinterName().$short_code;
	}

	public function getLintMessageSeverity($code) {
	$map = $this->customSeverityMap;
	if (isset($map[$code])) {
	return $map[$code];
	}

	$map = $this->getLintSeverityMap();
	if (isset($map[$code])) {
	return $map[$code];
	}

	return ArcanistLintSeverity::SEVERITY_ERROR;
	}

	public function isMessageEnabled($code) {
	return ($this->getLintMessageSeverity($code) !==
	ArcanistLintSeverity::SEVERITY_DISABLED);
	}

	public function getLintMessageName($code) {
	$map = $this->getLintNameMap();
	if (isset($map[$code])) {
	return $map[$code];
	}
	return "Unknown lint message!";
	}

	protected function addLintMessage(ArcanistLintMessage $message) {
	if (!$this->getEngine()->getCommitHookMode()) {
	$root = $this->getEngine()->getWorkingCopy()->getProjectRoot();
	$path = Filesystem::resolvePath($message->getPath(), $root);
	$message->setPath(Filesystem::readablePath($path, $root));
	}
	$this->messages[] = $message;
	return $message;
	}

	public function getLintMessages() {
	return $this->messages;
	}

	protected function newLintAtLine($line, $char, $code, $desc) {
	return id(new ArcanistLintMessage())
	->setPath($this->getActivePath())
	->setLine($line)
	->setChar($char)
	->setCode($this->getLintMessageFullCode($code))
	->setSeverity($this->getLintMessageSeverity($code))
	->setName($this->getLintMessageName($code))
	->setDescription($desc);
	}

	protected function raiseLintAtLine(
	$line,
	$char,
	$code,
	$desc,
	$original = null,
	$replacement = null) {

	$message = $this->newLintAtLine($line, $char, $code, $desc)
	->setOriginalText($original)
	->setReplacementText($replacement);

	return $this->addLintMessage($message);
	}

	protected function raiseLintAtPath(
	$code,
	$desc) {

	return $this->raiseLintAtLine(null, null, $code, $desc, null, null);
	}

	protected function raiseLintAtOffset(
	$offset,
	$code,
	$desc,
	$original = null,
	$replacement = null) {

	$path = $this->getActivePath();
	$engine = $this->getEngine();
	if ($offset === null) {
	$line = null;
	$char = null;
	} else {
	list($line, $char) = $engine->getLineAndCharFromOffset($path, $offset);
	}

	return $this->raiseLintAtLine(
	$line + 1,
	$char + 1,
	$code,
	$desc,
	$original,
	$replacement);
	}

	public function willLintPath($path) {
	$this->stopAllLinters = false;
	$this->activePath = $path;
	}

	public function canRun() {
	return true;
	}

	abstract public function willLintPaths(array $paths);
	abstract public function lintPath($path);
	abstract public function getLinterName();

	public function didRunLinters() {
	// This is a hook.
	}

	+ protected function isCodeEnabled($code) {
	+ $severity = $this->getLintMessageSeverity($code);
	+ return $this->getEngine()->isSeverityEnabled($severity);
	+ }
	+
	public function getLintSeverityMap() {
	return array();
	}

	public function getLintNameMap() {
	return array();
	}

	public function getCacheGranularity() {
	return self::GRANULARITY_FILE;
	}

	}
	diff --git a/src/lint/linter/ArcanistXHPASTLinter.php b/src/lint/linter/ArcanistXHPASTLinter.php
	index 52b55c74..4f6035ba 100644
	--- a/src/lint/linter/ArcanistXHPASTLinter.php
	+++ b/src/lint/linter/ArcanistXHPASTLinter.php
	@@ -1,2011 +1,2034 @@
	<?php

	/**
	* Uses XHPAST to apply lint rules to PHP.
	*
	* @group linter
	*/
	final class ArcanistXHPASTLinter extends ArcanistBaseXHPASTLinter {

	protected $trees = array();

	const LINT_PHP_SYNTAX_ERROR = 1;
	const LINT_UNABLE_TO_PARSE = 2;
	const LINT_VARIABLE_VARIABLE = 3;
	const LINT_EXTRACT_USE = 4;
	const LINT_UNDECLARED_VARIABLE = 5;
	const LINT_PHP_SHORT_TAG = 6;
	const LINT_PHP_ECHO_TAG = 7;
	const LINT_PHP_CLOSE_TAG = 8;
	const LINT_NAMING_CONVENTIONS = 9;
	const LINT_IMPLICIT_CONSTRUCTOR = 10;
	const LINT_DYNAMIC_DEFINE = 12;
	const LINT_STATIC_THIS = 13;
	const LINT_PREG_QUOTE_MISUSE = 14;
	const LINT_PHP_OPEN_TAG = 15;
	const LINT_TODO_COMMENT = 16;
	const LINT_EXIT_EXPRESSION = 17;
	const LINT_COMMENT_STYLE = 18;
	const LINT_CLASS_FILENAME_MISMATCH = 19;
	const LINT_TAUTOLOGICAL_EXPRESSION = 20;
	const LINT_PLUS_OPERATOR_ON_STRINGS = 21;
	const LINT_DUPLICATE_KEYS_IN_ARRAY = 22;
	const LINT_REUSED_ITERATORS = 23;
	const LINT_BRACE_FORMATTING = 24;
	const LINT_PARENTHESES_SPACING = 25;
	const LINT_CONTROL_STATEMENT_SPACING = 26;
	const LINT_BINARY_EXPRESSION_SPACING = 27;
	const LINT_ARRAY_INDEX_SPACING = 28;
	const LINT_RAGGED_CLASSTREE_EDGE = 29;
	const LINT_IMPLICIT_FALLTHROUGH = 30;
	const LINT_PHP_53_FEATURES = 31;
	const LINT_REUSED_AS_ITERATOR = 32;
	const LINT_COMMENT_SPACING = 34;
	const LINT_PHP_54_FEATURES = 35;
	const LINT_SLOWNESS = 36;


	public function getLintNameMap() {
	return array(
	self::LINT_PHP_SYNTAX_ERROR => 'PHP Syntax Error!',
	self::LINT_UNABLE_TO_PARSE => 'Unable to Parse',
	self::LINT_VARIABLE_VARIABLE => 'Use of Variable Variable',
	self::LINT_EXTRACT_USE => 'Use of extract()',
	self::LINT_UNDECLARED_VARIABLE => 'Use of Undeclared Variable',
	self::LINT_PHP_SHORT_TAG => 'Use of Short Tag "<?"',
	self::LINT_PHP_ECHO_TAG => 'Use of Echo Tag "<?="',
	self::LINT_PHP_CLOSE_TAG => 'Use of Close Tag "?>"',
	self::LINT_NAMING_CONVENTIONS => 'Naming Conventions',
	self::LINT_IMPLICIT_CONSTRUCTOR => 'Implicit Constructor',
	self::LINT_DYNAMIC_DEFINE => 'Dynamic define()',
	self::LINT_STATIC_THIS => 'Use of $this in Static Context',
	self::LINT_PREG_QUOTE_MISUSE => 'Misuse of preg_quote()',
	self::LINT_PHP_OPEN_TAG => 'Expected Open Tag',
	self::LINT_TODO_COMMENT => 'TODO Comment',
	self::LINT_EXIT_EXPRESSION => 'Exit Used as Expression',
	self::LINT_COMMENT_STYLE => 'Comment Style',
	self::LINT_CLASS_FILENAME_MISMATCH => 'Class-Filename Mismatch',
	self::LINT_TAUTOLOGICAL_EXPRESSION => 'Tautological Expression',
	self::LINT_PLUS_OPERATOR_ON_STRINGS => 'Not String Concatenation',
	self::LINT_DUPLICATE_KEYS_IN_ARRAY => 'Duplicate Keys in Array',
	self::LINT_REUSED_ITERATORS => 'Reuse of Iterator Variable',
	self::LINT_BRACE_FORMATTING => 'Brace placement',
	self::LINT_PARENTHESES_SPACING => 'Spaces Inside Parentheses',
	self::LINT_CONTROL_STATEMENT_SPACING => 'Space After Control Statement',
	self::LINT_BINARY_EXPRESSION_SPACING => 'Space Around Binary Operator',
	self::LINT_ARRAY_INDEX_SPACING => 'Spacing Before Array Index',
	self::LINT_RAGGED_CLASSTREE_EDGE => 'Class Not abstract Or final',
	self::LINT_IMPLICIT_FALLTHROUGH => 'Implicit Fallthrough',
	self::LINT_PHP_53_FEATURES => 'Use Of PHP 5.3 Features',
	self::LINT_PHP_54_FEATURES => 'Use Of PHP 5.4 Features',
	self::LINT_REUSED_AS_ITERATOR => 'Variable Reused As Iterator',
	self::LINT_COMMENT_SPACING => 'Comment Spaces',
	self::LINT_SLOWNESS => 'Slow Construct',
	);
	}

	public function getLinterName() {
	return 'XHP';
	}

	public function getLintSeverityMap() {
	$disabled = ArcanistLintSeverity::SEVERITY_DISABLED;
	$advice = ArcanistLintSeverity::SEVERITY_ADVICE;
	$warning = ArcanistLintSeverity::SEVERITY_WARNING;

	return array(
	self::LINT_TODO_COMMENT => $disabled,
	self::LINT_UNABLE_TO_PARSE => $warning,
	self::LINT_NAMING_CONVENTIONS => $warning,
	self::LINT_PREG_QUOTE_MISUSE => $advice,
	self::LINT_BRACE_FORMATTING => $warning,
	self::LINT_PARENTHESES_SPACING => $warning,
	self::LINT_CONTROL_STATEMENT_SPACING => $warning,
	self::LINT_BINARY_EXPRESSION_SPACING => $warning,
	self::LINT_ARRAY_INDEX_SPACING => $warning,
	self::LINT_IMPLICIT_FALLTHROUGH => $warning,
	self::LINT_SLOWNESS => $warning,
	self::LINT_COMMENT_SPACING => $advice,

	// This is disabled by default because it implies a very strict policy
	// which isn't necessary in the general case.
	self::LINT_RAGGED_CLASSTREE_EDGE => $disabled,

	// This is disabled by default because projects don't necessarily target
	// a specific minimum version.
	self::LINT_PHP_53_FEATURES => $disabled,
	self::LINT_PHP_54_FEATURES => $disabled,
	);
	}

	public function willLintPaths(array $paths) {
	$futures = array();
	foreach ($paths as $path) {
	if (array_key_exists($path, $this->trees)) {
	continue;
	}
	$futures[$path] = xhpast_get_parser_future($this->getData($path));
	}
	foreach (Futures($futures)->limit(8) as $path => $future) {
	$this->willLintPath($path);
	$this->trees[$path] = null;
	try {
	$this->trees[$path] = XHPASTTree::newFromDataAndResolvedExecFuture(
	$this->getData($path),
	$future->resolve());
	$root = $this->trees[$path]->getRootNode();
	$root->buildSelectCache();
	$root->buildTokenCache();
	} catch (XHPASTSyntaxErrorException $ex) {
	$this->raiseLintAtLine(
	$ex->getErrorLine(),
	1,
	self::LINT_PHP_SYNTAX_ERROR,
	'This file contains a syntax error: '.$ex->getMessage());
	$this->stopAllLinters();
	return;
	} catch (Exception $ex) {
	$this->raiseLintAtPath(
	self::LINT_UNABLE_TO_PARSE,
	'XHPAST could not parse this file, probably because the AST is too '.
	'deep. Some lint issues may not have been detected. You may safely '.
	'ignore this warning.');
	return;
	}
	}
	}

	public function getXHPASTTreeForPath($path) {
	return idx($this->trees, $path);
	}

	public function getCacheVersion() {
	$version = '2';
	$path = xhpast_get_binary_path();
	if (Filesystem::pathExists($path)) {
	$version .= '-'.md5_file($path);
	}
	return $version;
	}

	public function lintPath($path) {
	if (!$this->trees[$path]) {
	return;
	}

	$root = $this->trees[$path]->getRootNode();

	- $this->lintUseOfThisInStaticMethods($root);
	- $this->lintDynamicDefines($root);
	- $this->lintSurpriseConstructors($root);
	- $this->lintPHPTagUse($root);
	- $this->lintVariableVariables($root);
	- $this->lintTODOComments($root);
	- $this->lintExitExpressions($root);
	- $this->lintSpaceAroundBinaryOperators($root);
	- $this->lintSpaceAfterControlStatementKeywords($root);
	- $this->lintParenthesesShouldHugExpressions($root);
	- $this->lintNamingConventions($root);
	- $this->lintPregQuote($root);
	- $this->lintUndeclaredVariables($root);
	- $this->lintArrayIndexWhitespace($root);
	- $this->lintCommentSpaces($root);
	- $this->lintHashComments($root);
	- $this->lintPrimaryDeclarationFilenameMatch($root);
	- $this->lintTautologicalExpressions($root);
	- $this->lintPlusOperatorOnStrings($root);
	- $this->lintDuplicateKeysInArray($root);
	- $this->lintReusedIterators($root);
	- $this->lintBraceFormatting($root);
	- $this->lintRaggedClasstreeEdges($root);
	- $this->lintImplicitFallthrough($root);
	- $this->lintPHP53Features($root);
	- $this->lintPHP54Features($root);
	- $this->lintStrposUsedForStart($root);
	- $this->lintStrstrUsedForCheck($root);
	+ $method_codes = array(
	+ 'lintStrstrUsedForCheck' => self::LINT_SLOWNESS,
	+ 'lintStrposUsedForStart' => self::LINT_SLOWNESS,
	+ 'lintPHP53Features' => self::LINT_PHP_53_FEATURES,
	+ 'lintPHP54Features' => self::LINT_PHP_54_FEATURES,
	+ 'lintImplicitFallthrough' => self::LINT_IMPLICIT_FALLTHROUGH,
	+ 'lintBraceFormatting' => self::LINT_BRACE_FORMATTING,
	+ 'lintTautologicalExpressions' => self::LINT_TAUTOLOGICAL_EXPRESSION,
	+ 'lintCommentSpaces' => self::LINT_COMMENT_SPACING,
	+ 'lintHashComments' => self::LINT_COMMENT_STYLE,
	+ 'lintReusedIterators' => self::LINT_REUSED_ITERATORS,
	+ 'lintVariableVariables' => self::LINT_VARIABLE_VARIABLE,
	+ 'lintUndeclaredVariables' => array(
	+ self::LINT_EXTRACT_USE,
	+ self::LINT_REUSED_AS_ITERATOR,
	+ self::LINT_UNDECLARED_VARIABLE,
	+ ),
	+ 'lintPHPTagUse' => array(
	+ self::LINT_PHP_SHORT_TAG,
	+ self::LINT_PHP_ECHO_TAG,
	+ self::LINT_PHP_OPEN_TAG,
	+ self::LINT_PHP_CLOSE_TAG,
	+ ),
	+ 'lintNamingConventions' => self::LINT_NAMING_CONVENTIONS,
	+ 'lintSurpriseConstructors' => self::LINT_IMPLICIT_CONSTRUCTOR,
	+ 'lintParenthesesShouldHugExpressions' => self::LINT_PARENTHESES_SPACING,
	+ 'lintSpaceAfterControlStatementKeywords' =>
	+ self::LINT_CONTROL_STATEMENT_SPACING,
	+ 'lintSpaceAroundBinaryOperators' => self::LINT_BINARY_EXPRESSION_SPACING,
	+ 'lintDynamicDefines' => self::LINT_DYNAMIC_DEFINE,
	+ 'lintUseOfThisInStaticMethods' => self::LINT_STATIC_THIS,
	+ 'lintPregQuote' => self::LINT_PREG_QUOTE_MISUSE,
	+ 'lintExitExpressions' => self::LINT_EXIT_EXPRESSION,
	+ 'lintArrayIndexWhitespace' => self::LINT_ARRAY_INDEX_SPACING,
	+ 'lintTODOComments' => self::LINT_TODO_COMMENT,
	+ 'lintPrimaryDeclarationFilenameMatch' =>
	+ self::LINT_CLASS_FILENAME_MISMATCH,
	+ 'lintPlusOperatorOnStrings' => self::LINT_PLUS_OPERATOR_ON_STRINGS,
	+ 'lintDuplicateKeysInArray' => self::LINT_DUPLICATE_KEYS_IN_ARRAY,
	+ 'lintRaggedClasstreeEdges' => self::LINT_RAGGED_CLASSTREE_EDGE,
	+ );
	+
	+ foreach ($method_codes as $method => $codes) {
	+ foreach ((array)$codes as $code) {
	+ if ($this->isCodeEnabled($code)) {
	+ call_user_func(array($this, $method), $root);
	+ break;
	+ }
	+ }
	+ }
	+
	}

	public function lintStrstrUsedForCheck($root) {
	$expressions = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
	foreach ($expressions as $expression) {
	$operator = $expression->getChildOfType(1, 'n_OPERATOR');
	$operator = $operator->getConcreteString();

	if ($operator != '===' && $operator != '!==') {
	continue;
	}

	$false = $expression->getChildByIndex(0);
	if ($false->getTypeName() == 'n_SYMBOL_NAME' &&
	$false->getConcreteString() == 'false') {
	$strstr = $expression->getChildByIndex(2);
	} else {
	$strstr = $false;
	$false = $expression->getChildByIndex(2);
	if ($false->getTypeName() != 'n_SYMBOL_NAME' \|\|
	$false->getConcreteString() != 'false') {
	continue;
	}
	}

	if ($strstr->getTypeName() != 'n_FUNCTION_CALL') {
	continue;
	}

	$name = strtolower($strstr->getChildByIndex(0)->getConcreteString());
	if ($name == 'strstr' \|\| $name == 'strchr') {
	$this->raiseLintAtNode(
	$strstr,
	self::LINT_SLOWNESS,
	"Use strpos() for checking if the string contains something.");
	} else if ($name == 'stristr') {
	$this->raiseLintAtNode(
	$strstr,
	self::LINT_SLOWNESS,
	"Use stripos() for checking if the string contains something.");
	}
	}
	}

	public function lintStrposUsedForStart($root) {
	$expressions = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
	foreach ($expressions as $expression) {
	$operator = $expression->getChildOfType(1, 'n_OPERATOR');
	$operator = $operator->getConcreteString();

	if ($operator != '===' && $operator != '!==') {
	continue;
	}

	$zero = $expression->getChildByIndex(0);
	if ($zero->getTypeName() == 'n_NUMERIC_SCALAR' &&
	$zero->getConcreteString() == '0') {
	$strpos = $expression->getChildByIndex(2);
	} else {
	$strpos = $zero;
	$zero = $expression->getChildByIndex(2);
	if ($zero->getTypeName() != 'n_NUMERIC_SCALAR' \|\|
	$zero->getConcreteString() != '0') {
	continue;
	}
	}

	if ($strpos->getTypeName() != 'n_FUNCTION_CALL') {
	continue;
	}

	$name = strtolower($strpos->getChildByIndex(0)->getConcreteString());
	if ($name == 'strpos') {
	$this->raiseLintAtNode(
	$strpos,
	self::LINT_SLOWNESS,
	"Use strncmp() for checking if the string starts with something.");
	} else if ($name == 'stripos') {
	$this->raiseLintAtNode(
	$strpos,
	self::LINT_SLOWNESS,
	"Use strncasecmp() for checking if the string starts with ".
	"something.");
	}
	}
	}

	public function lintPHP53Features($root) {

	$functions = $root->selectTokensOfType('T_FUNCTION');
	foreach ($functions as $function) {

	$next = $function->getNextToken();
	while ($next) {
	if ($next->isSemantic()) {
	break;
	}
	$next = $next->getNextToken();
	}

	if ($next) {
	if ($next->getTypeName() == '(') {
	$this->raiseLintAtToken(
	$function,
	self::LINT_PHP_53_FEATURES,
	'This codebase targets PHP 5.2, but anonymous functions were '.
	'not introduced until PHP 5.3.');
	}
	}
	}

	$namespaces = $root->selectTokensOfType('T_NAMESPACE');
	foreach ($namespaces as $namespace) {
	$this->raiseLintAtToken(
	$namespace,
	self::LINT_PHP_53_FEATURES,
	'This codebase targets PHP 5.2, but namespaces were not introduced '.
	'until PHP 5.3.');
	}

	// NOTE: This is only "use x;", in anonymous functions the node type is
	// n_LEXICAL_VARIABLE_LIST even though both tokens are T_USE.

	// TODO: We parse n_USE in a slightly crazy way right now; that would be
	// a better selector once it's fixed.

	$uses = $root->selectDescendantsOfType('n_USE_LIST');
	foreach ($uses as $use) {
	$this->raiseLintAtNode(
	$use,
	self::LINT_PHP_53_FEATURES,
	'This codebase targets PHP 5.2, but namespaces were not introduced '.
	'until PHP 5.3.');
	}

	$statics = $root->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
	foreach ($statics as $static) {
	$name = $static->getChildByIndex(0);
	if ($name->getTypeName() != 'n_CLASS_NAME') {
	continue;
	}
	if ($name->getConcreteString() == 'static') {
	$this->raiseLintAtNode(
	$name,
	self::LINT_PHP_53_FEATURES,
	'This codebase targets PHP 5.2, but `static::` was not introduced '.
	'until PHP 5.3.');
	}
	}

	$ternaries = $root->selectDescendantsOfType('n_TERNARY_EXPRESSION');
	foreach ($ternaries as $ternary) {
	$yes = $ternary->getChildByIndex(1);
	if ($yes->getTypeName() == 'n_EMPTY') {
	$this->raiseLintAtNode(
	$ternary,
	self::LINT_PHP_53_FEATURES,
	'This codebase targets PHP 5.2, but short ternary was not '.
	'introduced until PHP 5.3.');
	}
	}

	$heredocs = $root->selectDescendantsOfType('n_HEREDOC');
	foreach ($heredocs as $heredoc) {
	if (preg_match('/^<<<[\'"]/', $heredoc->getConcreteString())) {
	$this->raiseLintAtNode(
	$heredoc,
	self::LINT_PHP_53_FEATURES,
	'This codebase targets PHP 5.2, but nowdoc was not introduced until '.
	'PHP 5.3.');
	}
	}

	$this->lintPHP53Functions($root);
	}

	private function lintPHP53Functions($root) {
	$target = phutil_get_library_root('arcanist').
	'/../resources/php_compat_info.json';
	$compat_info = json_decode(file_get_contents($target), true);

	$calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
	foreach ($calls as $call) {
	$node = $call->getChildByIndex(0);
	$name = strtolower($node->getConcreteString());
	$version = idx($compat_info['functions'], $name);
	$windows_version = idx($compat_info['functions_windows'], $name);
	if ($version) {
	$this->raiseLintAtNode(
	$node,
	self::LINT_PHP_53_FEATURES,
	"This codebase targets PHP 5.2.3, but `{$name}()` was not ".
	"introduced until PHP {$version}.");
	} else if (array_key_exists($name, $compat_info['params'])) {
	$params = $call->getChildOfType(1, 'n_CALL_PARAMETER_LIST');
	foreach (array_values($params->getChildren()) as $i => $param) {
	$version = idx($compat_info['params'][$name], $i);
	if ($version) {
	$this->raiseLintAtNode(
	$param,
	self::LINT_PHP_53_FEATURES,
	"This codebase targets PHP 5.2.3, but parameter ".($i + 1)." ".
	"of `{$name}()` was not introduced until PHP {$version}.");
	}
	}
	} else if ($windows_version !== null) {
	$this->raiseLintAtNode(
	$node,
	self::LINT_PHP_53_FEATURES,
	"This codebase targets PHP 5.2.3, but `{$name}()` is not available ".
	"on Windows".
	($windows_version ? " until PHP {$windows_version}" : "").".");
	}
	}

	$classes = $root->selectDescendantsOfType('n_CLASS_NAME');
	foreach ($classes as $node) {
	$name = strtolower($node->getConcreteString());
	$version = idx($compat_info['interfaces'], $name);
	$version = idx($compat_info['classes'], $name, $version);
	if ($version) {
	$this->raiseLintAtNode(
	$node,
	self::LINT_PHP_53_FEATURES,
	"This codebase targets PHP 5.2.3, but `{$name}` was not ".
	"introduced until PHP {$version}.");
	}
	}

	}

	public function lintPHP54Features($root) {
	$indexes = $root->selectDescendantsOfType('n_INDEX_ACCESS');
	foreach ($indexes as $index) {
	$left = $index->getChildByIndex(0);
	switch ($left->getTypeName()) {
	case 'n_FUNCTION_CALL':
	case 'n_METHOD_CALL':
	$this->raiseLintAtNode(
	$index->getChildByIndex(1),
	self::LINT_PHP_54_FEATURES,
	"The f()[...] syntax was not introduced until PHP 5.4, but this ".
	"codebase targets an earlier version of PHP. You can rewrite ".
	"this expression using idx().");
	break;
	}
	}
	}

	private function lintImplicitFallthrough($root) {
	$hook_obj = null;
	$working_copy = $this->getEngine()->getWorkingCopy();
	if ($working_copy) {
	$hook_class = $working_copy->getConfig('lint.xhpast.switchhook');
	if ($hook_class) {
	$hook_obj = newv($hook_class, array());
	assert_instances_of(array($hook_obj), 'ArcanistXHPASTLintSwitchHook');
	}
	}

	$switches = $root->selectDescendantsOfType('n_SWITCH');
	foreach ($switches as $switch) {
	$blocks = array();

	$cases = $switch->selectDescendantsOfType('n_CASE');
	foreach ($cases as $case) {
	$blocks[] = $case;
	}

	$defaults = $switch->selectDescendantsOfType('n_DEFAULT');
	foreach ($defaults as $default) {
	$blocks[] = $default;
	}


	foreach ($blocks as $key => $block) {
	// Collect all the tokens in this block which aren't at top level.
	// We want to ignore "break", and "continue" in these blocks.
	$lower_level = $block->selectDescendantsOfType('n_WHILE');
	$lower_level->add($block->selectDescendantsOfType('n_DO_WHILE'));
	$lower_level->add($block->selectDescendantsOfType('n_FOR'));
	$lower_level->add($block->selectDescendantsOfType('n_FOREACH'));
	$lower_level->add($block->selectDescendantsOfType('n_SWITCH'));
	$lower_level_tokens = array();
	foreach ($lower_level as $lower_level_block) {
	$lower_level_tokens += $lower_level_block->getTokens();
	}

	// Collect all the tokens in this block which aren't in this scope
	// (because they're inside class, function or interface declarations).
	// We want to ignore all of these tokens.
	$decls = $block->selectDescendantsOfType('n_FUNCTION_DECLARATION');
	$decls->add($block->selectDescendantsOfType('n_CLASS_DECLARATION'));
	// For completeness; these can't actually have anything.
	$decls->add($block->selectDescendantsOfType('n_INTERFACE_DECLARATION'));
	$different_scope_tokens = array();
	foreach ($decls as $decl) {
	$different_scope_tokens += $decl->getTokens();
	}

	$lower_level_tokens += $different_scope_tokens;

	// Get all the trailing nonsemantic tokens, since we need to look for
	// "fallthrough" comments past the end of the semantic block.

	$tokens = $block->getTokens();
	$last = end($tokens);
	while ($last && $last = $last->getNextToken()) {
	if (!$last->isSemantic()) {
	$tokens[$last->getTokenID()] = $last;
	}
	}

	$blocks[$key] = array(
	$tokens,
	$lower_level_tokens,
	$different_scope_tokens,
	);
	}

	foreach ($blocks as $token_lists) {
	list(
	$tokens,
	$lower_level_tokens,
	$different_scope_tokens) = $token_lists;

	// Test each block (case or default statement) to see if it's OK. It's
	// OK if:
	//
	// - it is empty; or
	// - it ends in break, return, throw, continue or exit at top level; or
	// - it has a comment with "fallthrough" in its text.

	// Empty blocks are OK, so we start this at `true` and only set it to
	// false if we find a statement.
	$block_ok = true;

	// Keeps track of whether the current statement is one that validates
	// the block (break, return, throw, continue) or something else.
	$statement_ok = false;

	foreach ($tokens as $token_id => $token) {
	if (!$token->isSemantic()) {
	// Liberally match "fall" in the comment text so that comments like
	// "fallthru", "fall through", "fallthrough", etc., are accepted.
	if (preg_match('/fall/i', $token->getValue())) {
	$block_ok = true;
	break;
	}
	continue;
	}

	$tok_type = $token->getTypeName();

	if ($tok_type == 'T_FUNCTION' \|\|
	$tok_type == 'T_CLASS' \|\|
	$tok_type == 'T_INTERFACE') {
	// These aren't statements, but mark the block as nonempty anyway.
	$block_ok = false;
	continue;
	}

	if ($tok_type == ';') {
	if ($statement_ok) {
	$statment_ok = false;
	} else {
	$block_ok = false;
	}
	continue;
	}

	if ($tok_type == 'T_BREAK' \|\|
	$tok_type == 'T_CONTINUE') {
	if (empty($lower_level_tokens[$token_id])) {
	$statement_ok = true;
	$block_ok = true;
	}
	continue;
	}

	if ($tok_type == 'T_RETURN' \|\|
	$tok_type == 'T_THROW' \|\|
	$tok_type == 'T_EXIT' \|\|
	($hook_obj && $hook_obj->checkSwitchToken($token))) {
	if (empty($different_scope_tokens[$token_id])) {
	$statement_ok = true;
	$block_ok = true;
	}
	continue;
	}
	}

	if (!$block_ok) {
	$this->raiseLintAtToken(
	head($tokens),
	self::LINT_IMPLICIT_FALLTHROUGH,
	"This 'case' or 'default' has a nonempty block which does not ".
	"end with 'break', 'continue', 'return', 'throw' or 'exit'. Did ".
	"you forget to add one of those? If you intend to fall through, ".
	"add a '// fallthrough' comment to silence this warning.");
	}
	}
	}
	}

	private function lintBraceFormatting($root) {

	foreach ($root->selectDescendantsOfType('n_STATEMENT_LIST') as $list) {
	$tokens = $list->getTokens();
	if (!$tokens \|\| head($tokens)->getValue() != '{') {
	continue;
	}
	list($before, $after) = $list->getSurroundingNonsemanticTokens();
	if (!$before) {
	$first = head($tokens);

	// Only insert the space if we're after a closing parenthesis. If
	// we're in a construct like "else{}", other rules will insert space
	// after the 'else' correctly.
	$prev = $first->getPrevToken();
	if (!$prev \|\| $prev->getValue() != ')') {
	continue;
	}

	$this->raiseLintAtToken(
	$first,
	self::LINT_BRACE_FORMATTING,
	'Put opening braces on the same line as control statements and '.
	'declarations, with a single space before them.',
	' '.$first->getValue());
	} else if (count($before) == 1) {
	$before = reset($before);
	if ($before->getValue() != ' ') {
	$this->raiseLintAtToken(
	$before,
	self::LINT_BRACE_FORMATTING,
	'Put opening braces on the same line as control statements and '.
	'declarations, with a single space before them.',
	' ');
	}
	}
	}

	}

	private function lintTautologicalExpressions($root) {
	$expressions = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');

	static $operators = array(
	'-' => true,
	'/' => true,
	'-=' => true,
	'/=' => true,
	'<=' => true,
	'<' => true,
	'==' => true,
	'===' => true,
	'!=' => true,
	'!==' => true,
	'>=' => true,
	'>' => true,
	);

	static $logical = array(
	'\|\|' => true,
	'&&' => true,
	);

	foreach ($expressions as $expr) {
	$operator = $expr->getChildByIndex(1)->getConcreteString();
	if (!empty($operators[$operator])) {
	$left = $expr->getChildByIndex(0)->getSemanticString();
	$right = $expr->getChildByIndex(2)->getSemanticString();

	if ($left == $right) {
	$this->raiseLintAtNode(
	$expr,
	self::LINT_TAUTOLOGICAL_EXPRESSION,
	'Both sides of this expression are identical, so it always '.
	'evaluates to a constant.');
	}
	}

	if (!empty($logical[$operator])) {
	$left = $expr->getChildByIndex(0)->getSemanticString();
	$right = $expr->getChildByIndex(2)->getSemanticString();

	// NOTE: These will be null to indicate "could not evaluate".
	$left = $this->evaluateStaticBoolean($left);
	$right = $this->evaluateStaticBoolean($right);

	if (($operator == '\|\|' && ($left === true \|\| $right === true)) \|\|
	($operator == '&&' && ($left === false \|\| $right === false))) {
	$this->raiseLintAtNode(
	$expr,
	self::LINT_TAUTOLOGICAL_EXPRESSION,
	'The logical value of this expression is static. Did you forget '.
	'to remove some debugging code?');
	}
	}
	}
	}


	/**
	* Statically evaluate a boolean value from an XHP tree.
	*
	* TODO: Improve this and move it to XHPAST proper?
	*
	* @param string The "semantic string" of a single value.
	* @return mixed ##true## or ##false## if the value could be evaluated
	* statically; ##null## if static evaluation was not possible.
	*/
	private function evaluateStaticBoolean($string) {
	switch (strtolower($string)) {
	case '0':
	case 'null':
	case 'false':
	return false;
	case '1':
	case 'true':
	return true;
	}
	return null;
	}


	protected function lintCommentSpaces($root) {
	foreach ($root->selectTokensOfType('T_COMMENT') as $comment) {
	$value = $comment->getValue();
	if ($value[0] != '#') {
	$match = null;
	if (preg_match('@^(/[/]+)[^/\s]@', $value, $match)) {
	$this->raiseLintAtOffset(
	$comment->getOffset(),
	self::LINT_COMMENT_SPACING,
	'Put space after comment start.',
	$match[1],
	$match[1].' ');
	}
	}
	}
	}


	protected function lintHashComments($root) {
	foreach ($root->selectTokensOfType('T_COMMENT') as $comment) {
	$value = $comment->getValue();
	if ($value[0] != '#') {
	continue;
	}

	$this->raiseLintAtOffset(
	$comment->getOffset(),
	self::LINT_COMMENT_STYLE,
	'Use "//" single-line comments, not "#".',
	'#',
	(preg_match('/^#\S/', $value) ? '// ' : '//'));
	}
	}

	/**
	* Find cases where loops get nested inside each other but use the same
	* iterator variable. For example:
	*
	* COUNTEREXAMPLE
	* foreach ($list as $thing) {
	* foreach ($stuff as $thing) { // <-- Raises an error for reuse of $thing
	* // ...
	* }
	* }
	*
	*/
	private function lintReusedIterators($root) {
	$used_vars = array();

	$for_loops = $root->selectDescendantsOfType('n_FOR');
	foreach ($for_loops as $for_loop) {
	$var_map = array();

	// Find all the variables that are assigned to in the for() expression.
	$for_expr = $for_loop->getChildOfType(0, 'n_FOR_EXPRESSION');
	$bin_exprs = $for_expr->selectDescendantsOfType('n_BINARY_EXPRESSION');
	foreach ($bin_exprs as $bin_expr) {
	if ($bin_expr->getChildByIndex(1)->getConcreteString() == '=') {
	$var = $bin_expr->getChildByIndex(0);
	$var_map[$var->getConcreteString()] = $var;
	}
	}

	$used_vars[$for_loop->getID()] = $var_map;
	}

	$foreach_loops = $root->selectDescendantsOfType('n_FOREACH');
	foreach ($foreach_loops as $foreach_loop) {
	$var_map = array();

	$foreach_expr = $foreach_loop->getChildOftype(0, 'n_FOREACH_EXPRESSION');

	// We might use one or two vars, i.e. "foreach ($x as $y => $z)" or
	// "foreach ($x as $y)".
	$possible_used_vars = array(
	$foreach_expr->getChildByIndex(1),
	$foreach_expr->getChildByIndex(2),
	);
	foreach ($possible_used_vars as $var) {
	if ($var->getTypeName() == 'n_EMPTY') {
	continue;
	}
	$name = $var->getConcreteString();
	$name = trim($name, '&'); // Get rid of ref silliness.
	$var_map[$name] = $var;
	}

	$used_vars[$foreach_loop->getID()] = $var_map;
	}

	$all_loops = $for_loops->add($foreach_loops);
	foreach ($all_loops as $loop) {
	$child_for_loops = $loop->selectDescendantsOfType('n_FOR');
	$child_foreach_loops = $loop->selectDescendantsOfType('n_FOREACH');
	$child_loops = $child_for_loops->add($child_foreach_loops);

	$outer_vars = $used_vars[$loop->getID()];
	foreach ($child_loops as $inner_loop) {
	$inner_vars = $used_vars[$inner_loop->getID()];
	$shared = array_intersect_key($outer_vars, $inner_vars);
	if ($shared) {
	$shared_desc = implode(', ', array_keys($shared));
	$message = $this->raiseLintAtNode(
	$inner_loop->getChildByIndex(0),
	self::LINT_REUSED_ITERATORS,
	"This loop reuses iterator variables ({$shared_desc}) from an ".
	"outer loop. You might be clobbering the outer iterator. Change ".
	"the inner loop to use a different iterator name.");

	$locations = array();
	foreach ($shared as $var) {
	$locations[] = $this->getOtherLocation($var->getOffset());
	}
	$message->setOtherLocations($locations);
	}
	}
	}
	}

	protected function lintVariableVariables($root) {
	$vvars = $root->selectDescendantsOfType('n_VARIABLE_VARIABLE');
	foreach ($vvars as $vvar) {
	$this->raiseLintAtNode(
	$vvar,
	self::LINT_VARIABLE_VARIABLE,
	'Rewrite this code to use an array. Variable variables are unclear '.
	'and hinder static analysis.');
	}
	}

	protected function lintUndeclaredVariables($root) {
	// These things declare variables in a function:
	// Explicit parameters
	// Assignment
	// Assignment via list()
	// Static
	// Global
	// Lexical vars
	// Builtins ($this)
	// foreach()
	// catch
	//
	// These things make lexical scope unknowable:
	// Use of extract()
	// Assignment to variable variables ($$x)
	// Global with variable variables
	//
	// These things don't count as "using" a variable:
	// isset()
	// empty()
	// Static class variables
	//
	// The general approach here is to find each function/method declaration,
	// then:
	//
	// 1. Identify all the variable declarations, and where they first occur
	// in the function/method declaration.
	// 2. Identify all the uses that don't really count (as above).
	// 3. Everything else must be a use of a variable.
	// 4. For each variable, check if any uses occur before the declaration
	// and warn about them.
	//
	// We also keep track of where lexical scope becomes unknowable (e.g.,
	// because the function calls extract() or uses dynamic variables,
	// preventing us from keeping track of which variables are defined) so we
	// can stop issuing warnings after that.

	$fdefs = $root->selectDescendantsOfType('n_FUNCTION_DECLARATION');
	$mdefs = $root->selectDescendantsOfType('n_METHOD_DECLARATION');
	$defs = $fdefs->add($mdefs);

	foreach ($defs as $def) {

	// We keep track of the first offset where scope becomes unknowable, and
	// silence any warnings after that. Default it to INT_MAX so we can min()
	// it later to keep track of the first problem we encounter.
	$scope_destroyed_at = PHP_INT_MAX;

	$declarations = array(
	'$this' => 0,
	) + array_fill_keys($this->getSuperGlobalNames(), 0);
	$declaration_tokens = array();
	$exclude_tokens = array();
	$vars = array();

	// First up, find all the different kinds of declarations, as explained
	// above. Put the tokens into the $vars array.

	$param_list = $def->getChildOfType(3, 'n_DECLARATION_PARAMETER_LIST');
	$param_vars = $param_list->selectDescendantsOfType('n_VARIABLE');
	foreach ($param_vars as $var) {
	$vars[] = $var;
	}

	// This is PHP5.3 closure syntax: function () use ($x) {};
	$lexical_vars = $def
	->getChildByIndex(4)
	->selectDescendantsOfType('n_VARIABLE');
	foreach ($lexical_vars as $var) {
	$vars[] = $var;
	}

	$body = $def->getChildByIndex(5);
	if ($body->getTypeName() == 'n_EMPTY') {
	// Abstract method declaration.
	continue;
	}

	$static_vars = $body
	->selectDescendantsOfType('n_STATIC_DECLARATION')
	->selectDescendantsOfType('n_VARIABLE');
	foreach ($static_vars as $var) {
	$vars[] = $var;
	}


	$global_vars = $body
	->selectDescendantsOfType('n_GLOBAL_DECLARATION_LIST');
	foreach ($global_vars as $var_list) {
	foreach ($var_list->getChildren() as $var) {
	if ($var->getTypeName() == 'n_VARIABLE') {
	$vars[] = $var;
	} else {
	// Dynamic global variable, i.e. "global $$x;".
	$scope_destroyed_at = min($scope_destroyed_at, $var->getOffset());
	// An error is raised elsewhere, no need to raise here.
	}
	}
	}

	$catches = $body
	->selectDescendantsOfType('n_CATCH')
	->selectDescendantsOfType('n_VARIABLE');
	foreach ($catches as $var) {
	$vars[] = $var;
	}

	$binary = $body->selectDescendantsOfType('n_BINARY_EXPRESSION');
	foreach ($binary as $expr) {
	if ($expr->getChildByIndex(1)->getConcreteString() != '=') {
	continue;
	}
	$lval = $expr->getChildByIndex(0);
	if ($lval->getTypeName() == 'n_VARIABLE') {
	$vars[] = $lval;
	} else if ($lval->getTypeName() == 'n_LIST') {
	// Recursivey grab everything out of list(), since the grammar
	// permits list() to be nested. Also note that list() is ONLY valid
	// as an lval assignments, so we could safely lift this out of the
	// n_BINARY_EXPRESSION branch.
	$assign_vars = $lval->selectDescendantsOfType('n_VARIABLE');
	foreach ($assign_vars as $var) {
	$vars[] = $var;
	}
	}

	if ($lval->getTypeName() == 'n_VARIABLE_VARIABLE') {
	$scope_destroyed_at = min($scope_destroyed_at, $lval->getOffset());
	// No need to raise here since we raise an error elsewhere.
	}
	}

	$calls = $body->selectDescendantsOfType('n_FUNCTION_CALL');
	foreach ($calls as $call) {
	$name = strtolower($call->getChildByIndex(0)->getConcreteString());

	if ($name == 'empty' \|\| $name == 'isset') {
	$params = $call
	->getChildOfType(1, 'n_CALL_PARAMETER_LIST')
	->selectDescendantsOfType('n_VARIABLE');
	foreach ($params as $var) {
	$exclude_tokens[$var->getID()] = true;
	}
	continue;
	}
	if ($name != 'extract') {
	continue;
	}
	$scope_destroyed_at = min($scope_destroyed_at, $call->getOffset());
	$this->raiseLintAtNode(
	$call,
	self::LINT_EXTRACT_USE,
	'Avoid extract(). It is confusing and hinders static analysis.');
	}

	// Now we have every declaration except foreach(), handled below. Build
	// two maps, one which just keeps track of which tokens are part of
	// declarations ($declaration_tokens) and one which has the first offset
	// where a variable is declared ($declarations).

	foreach ($vars as $var) {
	$concrete = $this->getConcreteVariableString($var);
	$declarations[$concrete] = min(
	idx($declarations, $concrete, PHP_INT_MAX),
	$var->getOffset());
	$declaration_tokens[$var->getID()] = true;
	}

	// Excluded tokens are ones we don't "count" as being uses, described
	// above. Put them into $exclude_tokens.

	$class_statics = $body
	->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
	$class_static_vars = $class_statics
	->selectDescendantsOfType('n_VARIABLE');
	foreach ($class_static_vars as $var) {
	$exclude_tokens[$var->getID()] = true;
	}


	// Find all the variables in scope, and figure out where they are used.
	// We want to find foreach() iterators which are both declared before and
	// used after the foreach() loop.

	$uses = array();

	$all_vars = $body->selectDescendantsOfType('n_VARIABLE');
	$all = array();

	// NOTE: $all_vars is not a real array so we can't unset() it.
	foreach ($all_vars as $var) {

	// Be strict since it's easier; we don't let you reuse an iterator you
	// declared before a loop after the loop, even if you're just assigning
	// to it.

	$concrete = $var->getConcreteString();
	$uses[$concrete][$var->getID()] = $var->getOffset();

	if (isset($declaration_tokens[$var->getID()])) {
	// We know this is part of a declaration, so it's fine.
	continue;
	}
	if (isset($exclude_tokens[$var->getID()])) {
	// We know this is part of isset() or similar, so it's fine.
	continue;
	}

	$all[$var->getID()] = $var;
	}


	// Do foreach() last, we want to handle implicit redeclaration of a
	// variable already in scope since this probably means we're ovewriting a
	// local.

	// NOTE: Processing foreach expressions in order allows programs which
	// reuse iterator variables in other foreach() loops -- this is fine. We
	// have a separate warning to prevent nested loops from reusing the same
	// iterators.

	$foreaches = $body->selectDescendantsOfType('n_FOREACH');
	$all_foreach_vars = array();
	foreach ($foreaches as $foreach) {
	$foreach_expr = $foreach->getChildOfType(0, 'n_FOREACH_EXPRESSION');

	$foreach_vars = array();

	// Determine the end of the foreach() loop.
	$foreach_tokens = $foreach->getTokens();
	$last_token = end($foreach_tokens);
	$foreach_end = $last_token->getOffset();

	$key_var = $foreach_expr->getChildByIndex(1);
	if ($key_var->getTypeName() == 'n_VARIABLE') {
	$foreach_vars[] = $key_var;
	}

	$value_var = $foreach_expr->getChildByIndex(2);
	if ($value_var->getTypeName() == 'n_VARIABLE') {
	$foreach_vars[] = $value_var;
	} else {
	// The root-level token may be a reference, as in:
	// foreach ($a as $b => &$c) { ... }
	// Reach into the n_VARIABLE_REFERENCE node to grab the n_VARIABLE
	// node.
	$foreach_vars[] = $value_var->getChildOfType(0, 'n_VARIABLE');
	}

	// Remove all uses of the iterators inside of the foreach() loop from
	// the $uses map.

	foreach ($foreach_vars as $var) {
	$concrete = $this->getConcreteVariableString($var);
	$offset = $var->getOffset();

	foreach ($uses[$concrete] as $id => $use_offset) {
	if (($use_offset >= $offset) && ($use_offset < $foreach_end)) {
	unset($uses[$concrete][$id]);
	}
	}

	$all_foreach_vars[] = $var;
	}
	}

	foreach ($all_foreach_vars as $var) {
	$concrete = $this->getConcreteVariableString($var);
	$offset = $var->getOffset();

	// If a variable was declared before a foreach() and is used after
	// it, raise a message.

	if (isset($declarations[$concrete])) {
	if ($declarations[$concrete] < $offset) {
	if (!empty($uses[$concrete]) &&
	max($uses[$concrete]) > $offset) {
	$message = $this->raiseLintAtNode(
	$var,
	self::LINT_REUSED_AS_ITERATOR,
	'This iterator variable is a previously declared local '.
	'variable. To avoid overwriting locals, do not reuse them '.
	'as iterator variables.');
	$message->setOtherLocations(array(
	$this->getOtherLocation($declarations[$concrete]),
	$this->getOtherLocation(max($uses[$concrete])),
	));
	}
	}
	}

	// This is a declaration, exclude it from the "declare variables prior
	// to use" check below.
	unset($all[$var->getID()]);

	$vars[] = $var;
	}

	// Now rebuild declarations to include foreach().

	foreach ($vars as $var) {
	$concrete = $this->getConcreteVariableString($var);
	$declarations[$concrete] = min(
	idx($declarations, $concrete, PHP_INT_MAX),
	$var->getOffset());
	$declaration_tokens[$var->getID()] = true;
	}

	// Issue a warning for every variable token, unless it appears in a
	// declaration, we know about a prior declaration, we have explicitly
	// exlcuded it, or scope has been made unknowable before it appears.

	$issued_warnings = array();
	foreach ($all as $id => $var) {
	if ($var->getOffset() >= $scope_destroyed_at) {
	// This appears after an extract() or $$var so we have no idea
	// whether it's legitimate or not. We raised a harshly-worded warning
	// when scope was made unknowable, so just ignore anything we can't
	// figure out.
	continue;
	}
	$concrete = $this->getConcreteVariableString($var);
	if ($var->getOffset() >= idx($declarations, $concrete, PHP_INT_MAX)) {
	// The use appears after the variable is declared, so it's fine.
	continue;
	}
	if (!empty($issued_warnings[$concrete])) {
	// We've already issued a warning for this variable so we don't need
	// to issue another one.
	continue;
	}
	$this->raiseLintAtNode(
	$var,
	self::LINT_UNDECLARED_VARIABLE,
	'Declare variables prior to use (even if you are passing them '.
	'as reference parameters). You may have misspelled this '.
	'variable name.');
	$issued_warnings[$concrete] = true;
	}
	}
	}

	private function getConcreteVariableString($var) {
	$concrete = $var->getConcreteString();
	// Strip off curly braces as in $obj->{$property}.
	$concrete = trim($concrete, '{}');
	return $concrete;
	}

	protected function lintPHPTagUse($root) {
	$tokens = $root->getTokens();
	foreach ($tokens as $token) {
	if ($token->getTypeName() == 'T_OPEN_TAG') {
	if (trim($token->getValue()) == '<?') {
	$this->raiseLintAtToken(
	$token,
	self::LINT_PHP_SHORT_TAG,
	'Use the full form of the PHP open tag, "<?php".',
	"<?php\n");
	}
	break;
	} else if ($token->getTypeName() == 'T_OPEN_TAG_WITH_ECHO') {
	$this->raiseLintAtToken(
	$token,
	self::LINT_PHP_ECHO_TAG,
	'Avoid the PHP echo short form, "<?=".');
	break;
	} else {
	if (!preg_match('/^#!/', $token->getValue())) {
	$this->raiseLintAtToken(
	$token,
	self::LINT_PHP_OPEN_TAG,
	'PHP files should start with "<?php", which may be preceded by '.
	'a "#!" line for scripts.');
	}
	break;
	}
	}

	foreach ($root->selectTokensOfType('T_CLOSE_TAG') as $token) {
	$this->raiseLintAtToken(
	$token,
	self::LINT_PHP_CLOSE_TAG,
	'Do not use the PHP closing tag, "?>".');
	}
	}

	protected function lintNamingConventions($root) {

	// We're going to build up a list of <type, name, token, error> tuples
	// and then try to instantiate a hook class which has the opportunity to
	// override us.
	$names = array();

	$classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
	foreach ($classes as $class) {
	$name_token = $class->getChildByIndex(1);
	$name_string = $name_token->getConcreteString();

	$names[] = array(
	'class',
	$name_string,
	$name_token,
	ArcanistXHPASTLintNamingHook::isUpperCamelCase($name_string)
	? null
	: 'Follow naming conventions: classes should be named using '.
	'UpperCamelCase.',
	);
	}

	$ifaces = $root->selectDescendantsOfType('n_INTERFACE_DECLARATION');
	foreach ($ifaces as $iface) {
	$name_token = $iface->getChildByIndex(1);
	$name_string = $name_token->getConcreteString();
	$names[] = array(
	'interface',
	$name_string,
	$name_token,
	ArcanistXHPASTLintNamingHook::isUpperCamelCase($name_string)
	? null
	: 'Follow naming conventions: interfaces should be named using '.
	'UpperCamelCase.',
	);
	}


	$functions = $root->selectDescendantsOfType('n_FUNCTION_DECLARATION');
	foreach ($functions as $function) {
	$name_token = $function->getChildByIndex(2);
	if ($name_token->getTypeName() == 'n_EMPTY') {
	// Unnamed closure.
	continue;
	}
	$name_string = $name_token->getConcreteString();
	$names[] = array(
	'function',
	$name_string,
	$name_token,
	ArcanistXHPASTLintNamingHook::isLowercaseWithUnderscores(
	ArcanistXHPASTLintNamingHook::stripPHPFunction($name_string))
	? null
	: 'Follow naming conventions: functions should be named using '.
	'lowercase_with_underscores.',
	);
	}


	$methods = $root->selectDescendantsOfType('n_METHOD_DECLARATION');
	foreach ($methods as $method) {
	$name_token = $method->getChildByIndex(2);
	$name_string = $name_token->getConcreteString();
	$names[] = array(
	'method',
	$name_string,
	$name_token,
	ArcanistXHPASTLintNamingHook::isLowerCamelCase(
	ArcanistXHPASTLintNamingHook::stripPHPFunction($name_string))
	? null
	: 'Follow naming conventions: methods should be named using '.
	'lowerCamelCase.',
	);
	}

	$param_tokens = array();

	$params = $root->selectDescendantsOfType('n_DECLARATION_PARAMETER_LIST');
	foreach ($params as $param_list) {
	foreach ($param_list->getChildren() as $param) {
	$name_token = $param->getChildByIndex(1);
	if ($name_token->getTypeName() == 'n_VARIABLE_REFERENCE') {
	$name_token = $name_token->getChildOfType(0, 'n_VARIABLE');
	}
	$param_tokens[$name_token->getID()] = true;
	$name_string = $name_token->getConcreteString();

	$names[] = array(
	'parameter',
	$name_string,
	$name_token,
	ArcanistXHPASTLintNamingHook::isLowercaseWithUnderscores(
	ArcanistXHPASTLintNamingHook::stripPHPVariable($name_string))
	? null
	: 'Follow naming conventions: parameters should be named using '.
	'lowercase_with_underscores.',
	);
	}
	}


	$constants = $root->selectDescendantsOfType(
	'n_CLASS_CONSTANT_DECLARATION_LIST');
	foreach ($constants as $constant_list) {
	foreach ($constant_list->getChildren() as $constant) {
	$name_token = $constant->getChildByIndex(0);
	$name_string = $name_token->getConcreteString();
	$names[] = array(
	'constant',
	$name_string,
	$name_token,
	ArcanistXHPASTLintNamingHook::isUppercaseWithUnderscores($name_string)
	? null
	: 'Follow naming conventions: class constants should be named '.
	'using UPPERCASE_WITH_UNDERSCORES.',
	);
	}
	}

	$member_tokens = array();

	$props = $root->selectDescendantsOfType('n_CLASS_MEMBER_DECLARATION_LIST');
	foreach ($props as $prop_list) {
	foreach ($prop_list->getChildren() as $token_id => $prop) {
	if ($prop->getTypeName() == 'n_CLASS_MEMBER_MODIFIER_LIST') {
	continue;
	}

	$name_token = $prop->getChildByIndex(0);
	$member_tokens[$name_token->getID()] = true;

	$name_string = $name_token->getConcreteString();
	$names[] = array(
	'member',
	$name_string,
	$name_token,
	ArcanistXHPASTLintNamingHook::isLowerCamelCase(
	ArcanistXHPASTLintNamingHook::stripPHPVariable($name_string))
	? null
	: 'Follow naming conventions: class properties should be named '.
	'using lowerCamelCase.',
	);
	}
	}

	$superglobal_map = array_fill_keys(
	$this->getSuperGlobalNames(),
	true);


	$fdefs = $root->selectDescendantsOfType('n_FUNCTION_DECLARATION');
	$mdefs = $root->selectDescendantsOfType('n_METHOD_DECLARATION');
	$defs = $fdefs->add($mdefs);

	foreach ($defs as $def) {
	$globals = $def->selectDescendantsOfType('n_GLOBAL_DECLARATION_LIST');
	$globals = $globals->selectDescendantsOfType('n_VARIABLE');

	$globals_map = array();
	foreach ($globals as $global) {
	$global_string = $global->getConcreteString();
	$globals_map[$global_string] = true;
	$names[] = array(
	'global',
	$global_string,
	$global,

	// No advice for globals, but hooks have an option to provide some.
	null);
	}

	// Exclude access of static properties, since lint will be raised at
	// their declaration if they're invalid and they may not conform to
	// variable rules. This is slightly overbroad (includes the entire
	// rhs of a "Class::..." token) to cover cases like "Class:$x[0]". These
	// varaibles are simply made exempt from naming conventions.
	$exclude_tokens = array();
	$statics = $def->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
	foreach ($statics as $static) {
	$rhs = $static->getChildByIndex(1);
	$rhs_vars = $def->selectDescendantsOfType('n_VARIABLE');
	foreach ($rhs_vars as $var) {
	$exclude_tokens[$var->getID()] = true;
	}
	}

	$vars = $def->selectDescendantsOfType('n_VARIABLE');
	foreach ($vars as $token_id => $var) {
	if (isset($member_tokens[$token_id])) {
	continue;
	}
	if (isset($param_tokens[$token_id])) {
	continue;
	}
	if (isset($exclude_tokens[$token_id])) {
	continue;
	}

	$var_string = $var->getConcreteString();

	// Awkward artifact of "$o->{$x}".
	$var_string = trim($var_string, '{}');

	if (isset($superglobal_map[$var_string])) {
	continue;
	}
	if (isset($globals_map[$var_string])) {
	continue;
	}

	$names[] = array(
	'variable',
	$var_string,
	$var,
	ArcanistXHPASTLintNamingHook::isLowercaseWithUnderscores(
	ArcanistXHPASTLintNamingHook::stripPHPVariable($var_string))
	? null
	: 'Follow naming conventions: variables should be named using '.
	'lowercase_with_underscores.',
	);
	}
	}

	$engine = $this->getEngine();
	$working_copy = $engine->getWorkingCopy();

	if ($working_copy) {
	// If a naming hook is configured, give it a chance to override the
	// default results for all the symbol names.
	$hook_class = $working_copy->getConfig('lint.xhpast.naminghook');
	if ($hook_class) {
	$hook_obj = newv($hook_class, array());
	foreach ($names as $k => $name_attrs) {
	list($type, $name, $token, $default) = $name_attrs;
	$result = $hook_obj->lintSymbolName($type, $name, $default);
	$names[$k][3] = $result;
	}
	}
	}

	// Raise anything we're left with.
	foreach ($names as $k => $name_attrs) {
	list($type, $name, $token, $result) = $name_attrs;
	if ($result) {
	$this->raiseLintAtNode(
	$token,
	self::LINT_NAMING_CONVENTIONS,
	$result);
	}
	}
	}

	protected function lintSurpriseConstructors($root) {
	$classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
	foreach ($classes as $class) {
	$class_name = $class->getChildByIndex(1)->getConcreteString();
	$methods = $class->selectDescendantsOfType('n_METHOD_DECLARATION');
	foreach ($methods as $method) {
	$method_name_token = $method->getChildByIndex(2);
	$method_name = $method_name_token->getConcreteString();
	if (strtolower($class_name) == strtolower($method_name)) {
	$this->raiseLintAtNode(
	$method_name_token,
	self::LINT_IMPLICIT_CONSTRUCTOR,
	'Name constructors __construct() explicitly. This method is a '.
	'constructor because it has the same name as the class it is '.
	'defined in.');
	}
	}
	}
	}

	protected function lintParenthesesShouldHugExpressions($root) {
	$calls = $root->selectDescendantsOfType('n_CALL_PARAMETER_LIST');
	$controls = $root->selectDescendantsOfType('n_CONTROL_CONDITION');
	$fors = $root->selectDescendantsOfType('n_FOR_EXPRESSION');
	$foreach = $root->selectDescendantsOfType('n_FOREACH_EXPRESSION');
	$decl = $root->selectDescendantsOfType('n_DECLARATION_PARAMETER_LIST');

	$all_paren_groups = $calls
	->add($controls)
	->add($fors)
	->add($foreach)
	->add($decl);
	foreach ($all_paren_groups as $group) {
	$tokens = $group->getTokens();

	$token_o = array_shift($tokens);
	$token_c = array_pop($tokens);
	if ($token_o->getTypeName() != '(') {
	throw new Exception('Expected open paren!');
	}
	if ($token_c->getTypeName() != ')') {
	throw new Exception('Expected close paren!');
	}

	$nonsem_o = $token_o->getNonsemanticTokensAfter();
	$nonsem_c = $token_c->getNonsemanticTokensBefore();

	if (!$nonsem_o) {
	continue;
	}

	$raise = array();

	$string_o = implode('', mpull($nonsem_o, 'getValue'));
	if (preg_match('/^[ ]+$/', $string_o)) {
	$raise[] = array($nonsem_o, $string_o);
	}

	if ($nonsem_o !== $nonsem_c) {
	$string_c = implode('', mpull($nonsem_c, 'getValue'));
	if (preg_match('/^[ ]+$/', $string_c)) {
	$raise[] = array($nonsem_c, $string_c);
	}
	}

	foreach ($raise as $warning) {
	list($tokens, $string) = $warning;
	$this->raiseLintAtOffset(
	reset($tokens)->getOffset(),
	self::LINT_PARENTHESES_SPACING,
	'Parentheses should hug their contents.',
	$string,
	'');
	}
	}
	}

	protected function lintSpaceAfterControlStatementKeywords($root) {
	foreach ($root->getTokens() as $id => $token) {
	switch ($token->getTypeName()) {
	case 'T_IF':
	case 'T_ELSE':
	case 'T_FOR':
	case 'T_FOREACH':
	case 'T_WHILE':
	case 'T_DO':
	case 'T_SWITCH':
	$after = $token->getNonsemanticTokensAfter();
	if (empty($after)) {
	$this->raiseLintAtToken(
	$token,
	self::LINT_CONTROL_STATEMENT_SPACING,
	'Convention: put a space after control statements.',
	$token->getValue().' ');
	} else if (count($after) == 1) {
	$space = head($after);

	// If we have an else clause with braces, $space may not be
	// a single white space. e.g.,
	//
	// if ($x)
	// echo 'foo'
	// else // <- $space is not " " but "\n ".
	// echo 'bar'
	//
	// We just require it starts with either a whitespace or a newline.
	if ($token->getTypeName() == 'T_ELSE' \|\|
	$token->getTypeName() == 'T_DO') {
	break;
	}

	if ($space->isAnyWhitespace() && $space->getValue() != ' ') {
	$this->raiseLintAtToken(
	$space,
	self::LINT_CONTROL_STATEMENT_SPACING,
	'Convention: put a single space after control statements.',
	' ');
	}
	}
	break;
	}
	}
	}

	protected function lintSpaceAroundBinaryOperators($root) {

	// NOTE: '.' is parsed as n_CONCATENATION_LIST, not n_BINARY_EXPRESSION,
	// so we don't select it here.

	$expressions = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
	foreach ($expressions as $expression) {
	$operator = $expression->getChildByIndex(1);
	$operator_value = $operator->getConcreteString();
	list($before, $after) = $operator->getSurroundingNonsemanticTokens();

	$replace = null;
	if (empty($before) && empty($after)) {
	$replace = " {$operator_value} ";
	} else if (empty($before)) {
	$replace = " {$operator_value}";
	} else if (empty($after)) {
	$replace = "{$operator_value} ";
	}

	if ($replace !== null) {
	$this->raiseLintAtNode(
	$operator,
	self::LINT_BINARY_EXPRESSION_SPACING,
	'Convention: logical and arithmetic operators should be '.
	'surrounded by whitespace.',
	$replace);
	}
	}

	$tokens = $root->selectTokensOfType(',');
	foreach ($tokens as $token) {
	$next = $token->getNextToken();
	switch ($next->getTypeName()) {
	case ')':
	case 'T_WHITESPACE':
	break;
	break;
	default:
	$this->raiseLintAtToken(
	$token,
	self::LINT_BINARY_EXPRESSION_SPACING,
	'Convention: comma should be followed by space.',
	', ');
	break;
	}
	}

	// TODO: Spacing around ".".
	// TODO: Spacing around default parameter assignment in function/method
	// declarations (which is not n_BINARY_EXPRESSION).
	}

	protected function lintDynamicDefines($root) {
	$calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
	foreach ($calls as $call) {
	$name = $call->getChildByIndex(0)->getConcreteString();
	if (strtolower($name) == 'define') {
	$parameter_list = $call->getChildOfType(1, 'n_CALL_PARAMETER_LIST');
	$defined = $parameter_list->getChildByIndex(0);
	if (!$defined->isStaticScalar()) {
	$this->raiseLintAtNode(
	$defined,
	self::LINT_DYNAMIC_DEFINE,
	'First argument to define() must be a string literal.');
	}
	}
	}
	}

	protected function lintUseOfThisInStaticMethods($root) {
	$classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
	foreach ($classes as $class) {
	$methods = $class->selectDescendantsOfType('n_METHOD_DECLARATION');
	foreach ($methods as $method) {

	$attributes = $method
	->getChildByIndex(0, 'n_METHOD_MODIFIER_LIST')
	->selectDescendantsOfType('n_STRING');

	$method_is_static = false;
	$method_is_abstract = false;
	foreach ($attributes as $attribute) {
	if (strtolower($attribute->getConcreteString()) == 'static') {
	$method_is_static = true;
	}
	if (strtolower($attribute->getConcreteString()) == 'abstract') {
	$method_is_abstract = true;
	}
	}

	if ($method_is_abstract) {
	continue;
	}

	if (!$method_is_static) {
	continue;
	}

	$body = $method->getChildOfType(5, 'n_STATEMENT_LIST');

	$variables = $body->selectDescendantsOfType('n_VARIABLE');
	foreach ($variables as $variable) {
	if ($method_is_static &&
	strtolower($variable->getConcreteString()) == '$this') {
	$this->raiseLintAtNode(
	$variable,
	self::LINT_STATIC_THIS,
	'You can not reference "$this" inside a static method.');
	}
	}
	}
	}
	}

	/**
	* preg_quote() takes two arguments, but the second one is optional because
	* it is possible to use (), [] or {} as regular expression delimiters. If
	* you don't pass a second argument, you're probably going to get something
	* wrong.
	*/
	protected function lintPregQuote($root) {
	$function_calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
	foreach ($function_calls as $call) {
	$name = $call->getChildByIndex(0)->getConcreteString();
	if (strtolower($name) === 'preg_quote') {
	$parameter_list = $call->getChildOfType(1, 'n_CALL_PARAMETER_LIST');
	if (count($parameter_list->getChildren()) !== 2) {
	$this->raiseLintAtNode(
	$call,
	self::LINT_PREG_QUOTE_MISUSE,
	'If you use pattern delimiters that require escaping (such as //, '.
	'but not ()) then you should pass two arguments to preg_quote(), '.
	'so that preg_quote() knows which delimiter to escape.');
	}
	}
	}
	}

	/**
	* Exit is parsed as an expression, but using it as such is almost always
	* wrong. That is, this is valid:
	*
	* strtoupper(33 * exit - 6);
	*
	* When exit is used as an expression, it causes the program to terminate with
	* exit code 0. This is likely not what is intended; these statements have
	* different effects:
	*
	* exit(-1);
	* exit -1;
	*
	* The former exits with a failure code, the latter with a success code!
	*/
	protected function lintExitExpressions($root) {
	$unaries = $root->selectDescendantsOfType('n_UNARY_PREFIX_EXPRESSION');
	foreach ($unaries as $unary) {
	$operator = $unary->getChildByIndex(0)->getConcreteString();
	if (strtolower($operator) == 'exit') {
	if ($unary->getParentNode()->getTypeName() != 'n_STATEMENT') {
	$this->raiseLintAtNode(
	$unary,
	self::LINT_EXIT_EXPRESSION,
	"Use exit as a statement, not an expression.");
	}
	}
	}
	}

	private function lintArrayIndexWhitespace($root) {
	$indexes = $root->selectDescendantsOfType('n_INDEX_ACCESS');
	foreach ($indexes as $index) {
	$tokens = $index->getChildByIndex(0)->getTokens();
	$last = array_pop($tokens);
	$trailing = $last->getNonsemanticTokensAfter();
	$trailing_text = implode('', mpull($trailing, 'getValue'));
	if (preg_match('/^ +$/', $trailing_text)) {
	$this->raiseLintAtOffset(
	$last->getOffset() + strlen($last->getValue()),
	self::LINT_ARRAY_INDEX_SPACING,
	'Convention: no spaces before index access.',
	$trailing_text,
	'');
	}
	}
	}

	protected function lintTODOComments($root) {
	$comments = $root->selectTokensOfType('T_COMMENT') +
	$root->selectTokensOfType('T_DOC_COMMENT');

	foreach ($comments as $token) {
	$value = $token->getValue();
	$matches = null;
	$preg = preg_match_all(
	'/TODO/',
	$value,
	$matches,
	PREG_OFFSET_CAPTURE);

	foreach ($matches[0] as $match) {
	list($string, $offset) = $match;
	$this->raiseLintAtOffset(
	$token->getOffset() + $offset,
	self::LINT_TODO_COMMENT,
	'This comment has a TODO.',
	$string);
	}
	}
	}

	/**
	* Lint that if the file declares exactly one interface or class,
	* the name of the file matches the name of the class,
	* unless the classname is funky like an XHP element.
	*/
	private function lintPrimaryDeclarationFilenameMatch($root) {
	$classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
	$interfaces = $root->selectDescendantsOfType('n_INTERFACE_DECLARATION');

	if (count($classes) + count($interfaces) != 1) {
	return;
	}

	$declarations = count($classes) ? $classes : $interfaces;
	$declarations->rewind();
	$declaration = $declarations->current();

	$decl_name = $declaration->getChildByIndex(1);
	$decl_string = $decl_name->getConcreteString();

	// Exclude strangely named classes, e.g. XHP tags.
	if (!preg_match('/^\w+$/', $decl_string)) {
	return;
	}

	$rename = $decl_string.'.php';

	$path = $this->getActivePath();
	$filename = basename($path);

	if ($rename == $filename) {
	return;
	}

	$this->raiseLintAtNode(
	$decl_name,
	self::LINT_CLASS_FILENAME_MISMATCH,
	"The name of this file differs from the name of the class or interface ".
	"it declares. Rename the file to '{$rename}'."
	);
	}

	private function lintPlusOperatorOnStrings($root) {
	$binops = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
	foreach ($binops as $binop) {
	$op = $binop->getChildByIndex(1);
	if ($op->getConcreteString() != '+') {
	continue;
	}

	$left = $binop->getChildByIndex(0);
	$right = $binop->getChildByIndex(2);
	if (($left->getTypeName() == 'n_STRING_SCALAR') \|\|
	($right->getTypeName() == 'n_STRING_SCALAR')) {
	$this->raiseLintAtNode(
	$binop,
	self::LINT_PLUS_OPERATOR_ON_STRINGS,
	"In PHP, '.' is the string concatenation operator, not '+'. This ".
	"expression uses '+' with a string literal as an operand.");
	}
	}
	}

	/**
	* Finds duplicate keys in array initializers, as in
	* array(1 => 'anything', 1 => 'foo'). Since the first entry is ignored,
	* this is almost certainly an error.
	*/
	private function lintDuplicateKeysInArray($root) {
	$array_literals = $root->selectDescendantsOfType('n_ARRAY_LITERAL');
	foreach ($array_literals as $array_literal) {
	$nodes_by_key = array();
	$keys_warn = array();
	$list_node = $array_literal->getChildByIndex(0);
	foreach ($list_node->getChildren() as $array_entry) {
	$key_node = $array_entry->getChildByIndex(0);

	switch ($key_node->getTypeName()) {
	case 'n_STRING_SCALAR':
	case 'n_NUMERIC_SCALAR':
	// Scalars: array(1 => 'v1', '1' => 'v2');
	$key = 'scalar:'.(string)$key_node->evalStatic();
	break;

	case 'n_SYMBOL_NAME':
	case 'n_VARIABLE':
	case 'n_CLASS_STATIC_ACCESS':
	// Constants: array(CONST => 'v1', CONST => 'v2');
	// Variables: array($a => 'v1', $a => 'v2');
	// Class constants and vars: array(C::A => 'v1', C::A => 'v2');
	$key = $key_node->getTypeName().':'.$key_node->getConcreteString();
	break;

	default:
	$key = null;
	break;
	}

	if ($key !== null) {
	if (isset($nodes_by_key[$key])) {
	$keys_warn[$key] = true;
	}
	$nodes_by_key[$key][] = $key_node;
	}
	}

	foreach ($keys_warn as $key => $_) {
	$node = array_pop($nodes_by_key[$key]);
	$message = $this->raiseLintAtNode(
	$node,
	self::LINT_DUPLICATE_KEYS_IN_ARRAY,
	"Duplicate key in array initializer. PHP will ignore all ".
	"but the last entry.");

	$locations = array();
	foreach ($nodes_by_key[$key] as $node) {
	$locations[] = $this->getOtherLocation($node->getOffset());
	}
	$message->setOtherLocations($locations);
	}
	}
	}

	private function lintRaggedClasstreeEdges($root) {
	$parser = new PhutilDocblockParser();

	$classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
	foreach ($classes as $class) {

	$is_final = false;
	$is_abstract = false;
	$is_concrete_extensible = false;

	$attributes = $class->getChildOfType(0, 'n_CLASS_ATTRIBUTES');
	foreach ($attributes->getChildren() as $child) {
	if ($child->getConcreteString() == 'final') {
	$is_final = true;
	}
	if ($child->getConcreteString() == 'abstract') {
	$is_abstract = true;
	}
	}

	$docblock = $class->getDocblockToken();
	if ($docblock) {
	list($text, $specials) = $parser->parse($docblock->getValue());
	$is_concrete_extensible = idx($specials, 'concrete-extensible');
	}

	if (!$is_final && !$is_abstract && !$is_concrete_extensible) {
	$this->raiseLintAtNode(
	$class->getChildOfType(1, 'n_CLASS_NAME'),
	self::LINT_RAGGED_CLASSTREE_EDGE,
	"This class is neither 'final' nor 'abstract', and does not have ".
	"a docblock marking it '@concrete-extensible'.");
	}
	}
	}

	public function getSuperGlobalNames() {
	return array(
	'$GLOBALS',
	'$_SERVER',
	'$_GET',
	'$_POST',
	'$_FILES',
	'$_COOKIE',
	'$_SESSION',
	'$_REQUEST',
	'$_ENV',
	);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 13:07 (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 556914
Default Alt Text: (93 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions